new-integration

Wrap third-party HTTP APIs into reusable domain integrations with typed models.

Updated Apr 14, 2026
One-click install
npx skills add https://github.com/weiloon1234/Forge-Starter --skill new-integration
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: new-integration
Source: https://github.com/weiloon1234/Forge-Starter/tree/main/.claude/skills/new-integration
Command: npx skills add https://github.com/weiloon1234/Forge-Starter --skill new-integration

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Wrapping third-party HTTP APIs or SDKs as reusable, domain-oriented integrations placed under src/domain/integrations. This skill codifies a pattern that includes typed request/response shapes, provider config, error mapping, HTTP client setup, retry / rate-limit strategy, and optional webhook wiring via new-route, enabling service, job, and event-driven usage.

Core Features & Use Cases

  • Domain-oriented API surface that hides provider specifics from services
  • Config-driven clients with per-provider config files (config/<provider>.toml) and .env overrides
  • Typed request/response models and error mapping to a common forge::Error
  • HTTP client selection and timeout handling with retry / rate-limit strategies
  • Optional webhook handling with dedicated routes and verification

Quick Start

Create a new integration module under src/domain/integrations and expose a typed API, a provider config file, and optional webhook wiring following the pattern described above.

Frequently Asked Questions about new-integration

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I wrap external APIs into domain integrations in Rust?

To wrap external APIs into domain integrations, you create a module under src/domain/integrations that exposes a domain-oriented API, uses config files for provider settings, and maps errors to a common type. This hides provider specifics from your application services.

What's the best way to handle API rate limits and retries for third-party providers?

Handling API rate limits and retries is managed within the integration layer by configuring HTTP client timeout and retry strategies. This encapsulates the resilience logic inside the domain integration rather than scattering it across services or jobs.

How do I map API errors to a common application error type?

You map API errors by converting third-party provider responses into a common application error type within the integration module. This ensures that services and event listeners handle a uniform error structure instead of provider-specific exceptions.

Can I use config files to manage different API provider settings?

Yes, you can use config files to manage API provider settings by placing them in config/<provider>.toml with optional .env overrides. This config-driven approach allows distinct HTTP client setups and credentials for each external service.

How do I route incoming webhooks for external API integrations?

You route incoming webhooks by wiring dedicated verification and routing paths via new-route. This allows event-driven usage where webhooks from providers trigger specific domain integration logic securely.

Does this pattern work for integrating services like Stripe and Twilio?

Yes, this pattern works for integrating services like Stripe, Twilio, Mailgun, and KYC/OAuth providers. It applies to any third-party HTTP API by standardizing request/response structures and webhook handling across all providers.