@agentforge-io/core 2.0.23 → 2.1.0

package/dist/services/orchestrator.service.js

@@ -39,10 +39,32 @@ class OrchestratorService {
             baseURL: anthropicConfig.baseURL,
         });
         this.logger = opts.logger ?? noopLogger;
+        this.resolveAgentHook = opts.resolveAgent;
         for (const agent of opts.agents) {
             this.agentsMap.set(agent.id, agent);
         }
     }
+    /**
+     * Lookup with dynamic-resolver fallback. Hits the static map first
+     * (built from the constructor's `agents` list — covers the bootstrap
+     * use case), then falls back to the host-supplied `resolveAgent`
+     * hook (used by Team orchestrators whose members are loaded from
+     * the database per-tenant). Resolved agents are cached in the map
+     * for the lifetime of the service to avoid re-fetching across a
+     * multi-turn conversation.
+     */
+    async resolveAgentDynamic(agentId) {
+        const cached = this.agentsMap.get(agentId);
+        if (cached)
+            return cached;
+        if (!this.resolveAgentHook)
+            return undefined;
+        const resolved = await this.resolveAgentHook(agentId);
+        if (!resolved)
+            return undefined;
+        this.agentsMap.set(resolved.id, resolved);
+        return resolved;
+    }
     /**
      * Run an agent. Orchestrators automatically get delegation tools injected.
      * Non-orchestrator agents fall straight through to the runner.
@@ -55,6 +77,204 @@ class OrchestratorService {
         this.logger.debug(`Running orchestrator "${agentId}" with subagents: ${agent.subAgents.join(', ')}`);
         return this.runOrchestratorLoop(agent, messages, context);
     }
+    /**
+     * Streaming variant. Orchestrators emit `delegation_start` /
+     * `delegation_result` chunks around each sub-agent invocation; the
+     * sub-agent's own chunks are forwarded byte-by-byte with their
+     * `actingAgentId` set so the client renders the member's avatar /
+     * name on the right bubble. Non-orchestrator agents short-circuit
+     * to the runner's stream.
+     *
+     * Implementation note: we drive the same Anthropic agentic loop as
+     * `runOrchestratorLoop` (no shortcut — the orchestrator's reasoning
+     * about WHO to delegate to is still a non-streamed messages.create
+     * call). The streaming part is the SUB-AGENT'S response, which is
+     * the part the visitor actually cares about seeing in real time.
+     */
+    async *stream(agentId, messages, context) {
+        const agent = (await this.resolveAgentDynamic(agentId)) ?? null;
+        if (!agent) {
+            throw new OrchestratorError('agent_not_found', `Agent "${agentId}" not found`);
+        }
+        if (!agent.canOrchestrate || !agent.subAgents?.length) {
+            // No-op orchestration — fall straight through. The runner's
+            // chunks won't carry `actingAgentId`, which is exactly what we
+            // want: this conversation is bound to one agent.
+            yield* this.runner.stream(agent, messages, context);
+            return;
+        }
+        this.logger.debug(`Streaming orchestrator "${agentId}" with subagents: ${agent.subAgents.join(', ')}`);
+        const delegationTools = this.buildDelegationTools(agent);
+        const model = agent.model ?? this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
+        const maxTokens = agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
+        const anthropicTools = delegationTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.inputSchema,
+        }));
+        let currentMessages = [...messages];
+        let totalUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+        };
+        const messageId = (0, crypto_1.randomUUID)();
+        // Hard cap on orchestrator loops. Without one, a misbehaving model
+        // could ping-pong delegate → think → delegate forever. Three hops
+        // is enough for any well-formed team flow; the system prompt also
+        // discourages chaining so this is mostly defense in depth.
+        const MAX_LOOPS = 3;
+        let loopCount = 0;
+        while (true) {
+            if (loopCount++ > MAX_LOOPS) {
+                yield {
+                    type: 'text_delta',
+                    delta: '\n\n(Orchestrator stopped: too many delegations in one turn.)',
+                };
+                break;
+            }
+            // Orchestrator's planning step — non-streamed. The model picks a
+            // member, we forward its prose as a single text_delta so the
+            // chat shows the "Routing to …" reasoning, then we drain the
+            // tool_use blocks one by one.
+            const response = await this.client.messages.create({
+                model,
+                max_tokens: maxTokens,
+                system: agent.systemPrompt,
+                messages: currentMessages,
+                tools: anthropicTools,
+            });
+            totalUsage = {
+                inputTokens: totalUsage.inputTokens + response.usage.input_tokens,
+                outputTokens: totalUsage.outputTokens + response.usage.output_tokens,
+                totalTokens: totalUsage.totalTokens +
+                    response.usage.input_tokens +
+                    response.usage.output_tokens,
+            };
+            // Emit orchestrator's own prose (the "Routing to Ana…" line).
+            // No actingAgentId — that means "this is the team speaking as
+            // itself", which the client renders with the team's branding.
+            for (const block of response.content) {
+                if (block.type === 'text' && block.text.trim()) {
+                    yield { type: 'text_delta', delta: block.text };
+                }
+            }
+            if (response.stop_reason !== 'tool_use') {
+                // No delegation this turn — we're done.
+                break;
+            }
+            // Append the orchestrator's tool-use turn so the next loop sees
+            // it as part of the planning history.
+            const assistantMsg = {
+                role: 'assistant',
+                content: response.content,
+            };
+            currentMessages = [...currentMessages, assistantMsg];
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type !== 'tool_use')
+                    continue;
+                const delegateTool = delegationTools.find((t) => t.name === block.name);
+                if (!delegateTool)
+                    continue;
+                const { task } = block.input;
+                const { subAgentId } = delegateTool;
+                const subAgent = await this.resolveAgentDynamic(subAgentId);
+                // delegation_start carries the member's identity so the client
+                // can render the routing hint AND swap the active bubble's
+                // avatar before the first text_delta arrives.
+                yield {
+                    type: 'delegation_start',
+                    subAgentId,
+                    subAgentName: subAgent?.name,
+                    subAgentAvatarUrl: undefined,
+                    task,
+                };
+                if (!subAgent) {
+                    // Member was deleted between team config + the orchestrator
+                    // call. Synthesize a tool_result so the orchestrator can
+                    // apologize on its next loop.
+                    const errMsg = `Sub-agent "${subAgentId}" is no longer available.`;
+                    yield {
+                        type: 'delegation_result',
+                        subAgentId,
+                        result: errMsg,
+                    };
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: block.id,
+                        content: errMsg,
+                    });
+                    continue;
+                }
+                // Stream the sub-agent's reply through the runner, tagging every
+                // chunk with the member's id so the client renders it with the
+                // member's identity. We accumulate the text body so the
+                // orchestrator's next loop can see what the member said.
+                const subMessages = [{ role: 'user', content: task }];
+                let assembled = '';
+                let subUsage = {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    totalTokens: 0,
+                };
+                for await (const chunk of this.runner.stream(subAgent, subMessages, {
+                    ...context,
+                    agentId: subAgentId,
+                })) {
+                    // text_delta is the only chunk type whose body we accumulate
+                    // for the orchestrator's tool_result. Other chunks (tool
+                    // calls inside the member, usage updates) we forward to the
+                    // visitor but don't feed back to the orchestrator.
+                    if (chunk.type === 'text_delta') {
+                        assembled += chunk.delta;
+                        yield { ...chunk, actingAgentId: subAgentId };
+                        continue;
+                    }
+                    if (chunk.type === 'usage') {
+                        subUsage = chunk.usage;
+                        yield { ...chunk, actingAgentId: subAgentId };
+                        continue;
+                    }
+                    if (chunk.type === 'done') {
+                        // Swallow the inner `done` — the OUTER loop emits its own
+                        // when the whole orchestrator turn ends.
+                        continue;
+                    }
+                    // Pass-through with identity tag (tool_use_start, tool_result,
+                    // awaiting_approval, tool_blocked, etc.).
+                    yield { ...chunk, actingAgentId: subAgentId };
+                }
+                totalUsage.inputTokens += subUsage.inputTokens;
+                totalUsage.outputTokens += subUsage.outputTokens;
+                totalUsage.totalTokens += subUsage.totalTokens;
+                yield {
+                    type: 'delegation_result',
+                    subAgentId,
+                    result: assembled,
+                };
+                toolResults.push({
+                    type: 'tool_result',
+                    tool_use_id: block.id,
+                    // Anthropic rejects empty user-message content with a 400. A
+                    // sub-agent can produce zero text_deltas legitimately (it ran
+                    // only tools and never spoke) — when that happens we feed a
+                    // sentinel string back into the orchestrator's next loop so
+                    // the conversation stays well-formed. The sentinel doubles as
+                    // a signal the orchestrator can interpret ("the member acted
+                    // silently — decide whether to ask the user for confirmation").
+                    content: assembled || '(member completed silently — no textual response)',
+                });
+            }
+            // Feed the tool results back into the orchestrator's next loop.
+            currentMessages = [
+                ...currentMessages,
+                { role: 'user', content: toolResults },
+            ];
+        }
+        yield { type: 'usage', usage: totalUsage };
+        yield { type: 'done', messageId };
+    }
     async runOrchestratorLoop(orchestrator, messages, context) {
         const delegations = [];
         const delegationTools = this.buildDelegationTools(orchestrator);

package/dist/types/agent.types.d.ts

@@ -165,29 +165,54 @@ export interface ApprovalCopyBundle {
     blockedBody: string;
     expiresPrefix: string;
 }
-export type StreamChunk = {
+/**
+ * Per-chunk identity. When a Team orchestrator delegates a turn to a
+ * member, the streaming chunks coming out of the member carry the
+ * member's `agentId` here so the chat client can render a bubble with
+ * the member's avatar and name. Optional everywhere — when absent the
+ * client falls back to the session's primary agent identity (the
+ * default, non-team behaviour).
+ *
+ * The orchestrator's OWN chunks (the routing wrappers it speaks as
+ * itself) carry no `actingAgentId` so the client renders them as the
+ * team / orchestrator identity. The boundary between members is marked
+ * by `delegation_start` and `delegation_result`.
+ */
+export interface ActingAgentTag {
+    /** Id of the agent producing this chunk. When absent, treat the
+     *  chunk as coming from the session's primary agent (legacy
+     *  non-team behaviour). */
+    actingAgentId?: string;
+}
+export type StreamChunk = ({
     type: 'text_delta';
     delta: string;
-} | {
+} & ActingAgentTag) | ({
     type: 'tool_use_start';
     toolName: string;
     toolUseId: string;
-} | {
+} & ActingAgentTag) | ({
     type: 'tool_result';
     toolName: string;
     result: string;
-} | {
+} & ActingAgentTag) | {
     type: 'delegation_start';
     subAgentId: string;
     task: string;
+    /** Display name of the sub-agent. Lets the client render the
+     *  "Routing to <name>…" hint without a separate roster fetch. */
+    subAgentName?: string;
+    /** Optional avatar URL of the sub-agent — used by the chat client
+     *  to swap the avatar column for the member's bubble. */
+    subAgentAvatarUrl?: string;
 } | {
     type: 'delegation_result';
     subAgentId: string;
     result: string;
-} | {
+} | ({
     type: 'usage';
     usage: TokenUsage;
-} | {
+} & ActingAgentTag) | {
     /**
      * Emitted by the runtime when a tool dispatch hit
      * `ToolApprovalGate.check() → { kind: 'approval' }`. The stream

package/dist/types/config.types.d.ts

@@ -72,8 +72,15 @@ export interface AgentDefinition {
     name: string;
     /** Agent description (shown to users) */
     description?: string;
-    /** Claude model to use */
+    /** Claude model to use. Ignored when `modelStrategy` is set —
+     *  the strategy's `default` takes precedence as the base tier. */
     model?: string;
+    /** Adaptive model selection per turn. When present the runner
+     *  calls `selectModel(strategy, signals)` and routes between
+     *  Haiku / Sonnet / Opus according to operator-declared rules.
+     *  When absent the runner falls back to the legacy `model` /
+     *  `defaultModel` chain — zero breaking change. */
+    modelStrategy?: import('./model-strategy').ModelStrategy;
     /** System prompt */
     systemPrompt: string;
     /** Max tokens per response */

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './agent.types';
 export * from './config.types';
 export * from './hooks';
+export * from './model-strategy';

package/dist/types/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent.types"), exports);
 __exportStar(require("./config.types"), exports);
 __exportStar(require("./hooks"), exports);
+__exportStar(require("./model-strategy"), exports);

package/dist/types/model-strategy.d.ts

@@ -0,0 +1,97 @@
+/** The three Claude tiers the platform routes between today. New
+ *  providers / families will land here once the SDK speaks them. */
+export type ModelTier = 'haiku' | 'sonnet' | 'opus';
+/** Conditions that can push a turn UP to the escalation tier. */
+export type EscalateRule = 
+/** The agent has at least one tool attached to this turn. Tool use
+ *  benefits disproportionately from a stronger reasoner — Haiku
+ *  often picks the wrong tool or skips required arguments. */
+'toolUse'
+/** Estimated input tokens exceed `thresholds.longContextTokens`.
+ *  Long context degrades quality fastest on cheaper tiers. */
+ | 'longContext'
+/** At least one of the attached tools is in `approval` mode (a
+ *  human will gate the run). Escalate so the reasoning the human
+ *  reviews is as good as we can afford on a critical path. */
+ | 'approvalRequired';
+/** Conditions that can drop a turn DOWN to the fallback tier. Only
+ *  applied when no escalate rule fires — escalation always wins. */
+export type FallbackRule = 
+/** Estimated input tokens below `thresholds.shortInputTokens`.
+ *  "Hola", "thanks", confirmations, one-line clarifications —
+ *  Haiku is more than enough and costs ~12× less than Opus. */
+'shortInput';
+export interface ModelStrategy {
+    kind: 'fixed' | 'tiered';
+    /** The base model. Used as-is when `kind === 'fixed'`, and as the
+     *  middle tier when `kind === 'tiered'` (every turn that doesn't
+     *  trigger an escalate / fallback rule lands here). Free-form
+     *  string so future Anthropic model ids drop in without a SDK
+     *  release. */
+    default: string;
+    /** Concrete model ids for each tier. Only consulted when
+     *  `kind === 'tiered'`. Missing tiers mean "stay on default" so the
+     *  operator can declare a partial ladder (e.g. only the Haiku
+     *  fallback, no Opus escalation). */
+    tiers?: {
+        haiku?: string;
+        sonnet?: string;
+        opus?: string;
+    };
+    /** Conditions that escalate the turn to `tiers.opus`. Order does
+     *  not matter — any rule firing escalates. */
+    escalate?: EscalateRule[];
+    /** Conditions that drop the turn to `tiers.haiku`. Only applied
+     *  when no escalate rule fires. */
+    fallback?: FallbackRule[];
+    /** Thresholds the rules read. Sensible defaults below; operators
+     *  can override per agent. */
+    thresholds?: {
+        /** `longContext` fires when estimated input exceeds this. */
+        longContextTokens?: number;
+        /** `shortInput` fires when estimated input is below this. */
+        shortInputTokens?: number;
+    };
+}
+/** Defaults applied when the operator doesn't set thresholds. Picked
+ *  from the Anthropic cost / quality curve we've seen in practice:
+ *
+ *  - 8k input tokens is where Sonnet's quality on long contexts
+ *    starts to noticeably drift from Opus.
+ *  - 200 tokens covers single-sentence inputs (greetings,
+ *    confirmations) where Haiku is indistinguishable from Sonnet for
+ *    the user.
+ */
+export declare const DEFAULT_LONG_CONTEXT_TOKENS = 8000;
+export declare const DEFAULT_SHORT_INPUT_TOKENS = 200;
+/** Inputs the runner provides per turn so the selector can decide
+ *  without re-deriving anything. All optional — missing signals just
+ *  cause the corresponding rules to no-op. */
+export interface TurnSignals {
+    /** Estimated input tokens for this turn (system prompt + history
+     *  + new message). The runner can use `usage.input_tokens` from
+     *  the previous turn as a proxy; for the first turn a crude
+     *  word-count heuristic is good enough. */
+    estimatedInputTokens?: number;
+    /** True if the agent has at least one tool attached to this turn
+     *  (whether or not the model ends up calling it). */
+    hasTools?: boolean;
+    /** True if any attached tool is in `mode: 'approval'`. */
+    hasApprovalTool?: boolean;
+}
+export interface ModelSelection {
+    /** The model id the runner should pass to `messages.create`. */
+    model: string;
+    /** Which leg of the strategy fired. `default` = neither escalate
+     *  nor fallback matched; `escalate` / `fallback` = a rule fired
+     *  AND the corresponding tier was declared. `forced` = the
+     *  strategy is `fixed`. */
+    reason: 'forced' | 'default' | 'escalate' | 'fallback';
+    /** When `reason === 'escalate' | 'fallback'`, the rule that fired.
+     *  Used in telemetry so an operator can see why their bill
+     *  spiked. */
+    trigger?: EscalateRule | FallbackRule;
+}
+/** Pure decision function. The runner calls this once per turn just
+ *  before `messages.create`. */
+export declare function selectModel(strategy: ModelStrategy | undefined, signals: TurnSignals, runnerDefault: string): ModelSelection;

package/dist/types/model-strategy.js

@@ -0,0 +1,83 @@
+"use strict";
+// Adaptive model selection for a single agent turn.
+//
+// An agent may declare ONE of two strategies:
+//
+//   - `fixed`  → use `agent.model` (or the runner's default) for every
+//                turn. The historical behaviour. Zero overhead, zero
+//                variance. Use this when cost is a non-issue or the
+//                domain is uniform (e.g. always-creative writing).
+//
+//   - `tiered` → at each turn the runner inspects the request and
+//                may escalate to a more capable model OR fall back to
+//                a cheaper one based on a small set of heuristics
+//                declared by the operator. No LLM-router overhead —
+//                the decision is a pure function of the turn's shape
+//                (estimated input tokens, whether tools are attached,
+//                whether the turn will route through human approval).
+//
+// The decision lives in `selectModel(strategy, signals)` below so the
+// runner only calls one function and the policy stays testable in
+// isolation.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHORT_INPUT_TOKENS = exports.DEFAULT_LONG_CONTEXT_TOKENS = void 0;
+exports.selectModel = selectModel;
+/** Defaults applied when the operator doesn't set thresholds. Picked
+ *  from the Anthropic cost / quality curve we've seen in practice:
+ *
+ *  - 8k input tokens is where Sonnet's quality on long contexts
+ *    starts to noticeably drift from Opus.
+ *  - 200 tokens covers single-sentence inputs (greetings,
+ *    confirmations) where Haiku is indistinguishable from Sonnet for
+ *    the user.
+ */
+exports.DEFAULT_LONG_CONTEXT_TOKENS = 8_000;
+exports.DEFAULT_SHORT_INPUT_TOKENS = 200;
+/** Pure decision function. The runner calls this once per turn just
+ *  before `messages.create`. */
+function selectModel(strategy, signals, runnerDefault) {
+    // No strategy → behave exactly like before this feature landed.
+    if (!strategy) {
+        return { model: runnerDefault, reason: 'default' };
+    }
+    if (strategy.kind === 'fixed') {
+        return { model: strategy.default || runnerDefault, reason: 'forced' };
+    }
+    // Tiered. Escalate beats fallback (a long-context tool-use turn is
+    // not a `shortInput` even if the new message is two words).
+    const longCtx = strategy.thresholds?.longContextTokens ?? exports.DEFAULT_LONG_CONTEXT_TOKENS;
+    const shortIn = strategy.thresholds?.shortInputTokens ?? exports.DEFAULT_SHORT_INPUT_TOKENS;
+    const escalate = strategy.escalate ?? [];
+    const fallback = strategy.fallback ?? [];
+    for (const rule of escalate) {
+        if (rule === 'toolUse' && signals.hasTools) {
+            return pickTier(strategy, 'opus', 'escalate', rule);
+        }
+        if (rule === 'longContext' &&
+            typeof signals.estimatedInputTokens === 'number' &&
+            signals.estimatedInputTokens > longCtx) {
+            return pickTier(strategy, 'opus', 'escalate', rule);
+        }
+        if (rule === 'approvalRequired' && signals.hasApprovalTool) {
+            return pickTier(strategy, 'opus', 'escalate', rule);
+        }
+    }
+    for (const rule of fallback) {
+        if (rule === 'shortInput' &&
+            typeof signals.estimatedInputTokens === 'number' &&
+            signals.estimatedInputTokens < shortIn) {
+            return pickTier(strategy, 'haiku', 'fallback', rule);
+        }
+    }
+    return { model: strategy.default || runnerDefault, reason: 'default' };
+}
+function pickTier(strategy, tier, reason, trigger) {
+    const tiered = strategy.tiers?.[tier];
+    // No model declared for this tier → don't escalate/fallback to a
+    // ghost id; stay on default. Surface the rule that WOULD have
+    // fired so telemetry still captures the near-miss.
+    if (!tiered) {
+        return { model: strategy.default, reason: 'default', trigger };
+    }
+    return { model: tiered, reason, trigger };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-io/core",
-  "version": "2.0.23",
+  "version": "2.1.0",
   "description": "Framework-free AI runtime SDK. Owns: agent loop (Anthropic), conversations, tools, streaming, agent-job queue, SdkHooks. Identity, billing, infra (email/uploads/secrets) live in the host's modules — not here.",
   "license": "MIT",
   "main": "dist/index.js",

package/dist/adapters/billing/billing-adapter.interface.d.ts

@@ -1,41 +0,0 @@
-import type { CheckoutSession, CreateCheckoutParams, CreateCustomerParams, CreateSubscriptionParams, SubscriptionResult, WebhookEvent } from '../../types';
-/**
- * IBillingAdapter defines the contract for payment providers.
- * Implement this interface to support any payment gateway (Stripe, Paddle, LemonSqueezy, etc.)
- */
-export interface IBillingAdapter {
-    /**
-     * Create a Stripe Checkout (or equivalent) session for a subscription or one-time payment.
-     */
-    createCheckoutSession(params: CreateCheckoutParams): Promise<CheckoutSession>;
-    /**
-     * Programmatically create a subscription (without hosted checkout).
-     */
-    createSubscription(params: CreateSubscriptionParams): Promise<SubscriptionResult>;
-    /**
-     * Cancel a subscription (optionally at period end).
-     */
-    cancelSubscription(subscriptionId: string, atPeriodEnd?: boolean): Promise<void>;
-    /**
-     * Handle an incoming webhook from the payment provider.
-     * Returns a normalized WebhookEvent.
-     */
-    handleWebhook(payload: Buffer, signature: string): Promise<WebhookEvent>;
-    /**
-     * Generate a customer portal URL where users can manage their subscription.
-     */
-    getPortalUrl(customerId: string, returnUrl: string): Promise<string>;
-    /**
-     * Create a customer record in the payment provider.
-     * Returns the provider-specific customer ID.
-     */
-    createCustomer(params: CreateCustomerParams): Promise<string>;
-    /**
-     * Get the current subscription status from the provider.
-     */
-    getSubscription(subscriptionId: string): Promise<SubscriptionResult & {
-        status: string;
-    }>;
-}
-/** Token to inject the billing adapter via NestJS DI */
-export declare const BILLING_ADAPTER = "BILLING_ADAPTER";

package/dist/adapters/billing/billing-adapter.interface.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BILLING_ADAPTER = void 0;
-/** Token to inject the billing adapter via NestJS DI */
-exports.BILLING_ADAPTER = 'BILLING_ADAPTER';

package/dist/adapters/billing/stripe/stripe.adapter.d.ts

@@ -1,30 +0,0 @@
-import Stripe from 'stripe';
-import type { IBillingAdapter } from '../billing-adapter.interface';
-import type { CheckoutSession, CreateCheckoutParams, CreateCustomerParams, CreateSubscriptionParams, PlanDefinition, StripeConfig, SubscriptionResult, WebhookEvent } from '../../../types';
-interface MiniLogger {
-    debug?: (m: string) => void;
-    warn?: (m: string) => void;
-    log?: (m: string) => void;
-}
-/**
- * StripeAdapter implements IBillingAdapter using the Stripe API.
- * Handles subscriptions, pay-per-use checkouts, webhooks, and customer portal.
- */
-export declare class StripeAdapter implements IBillingAdapter {
-    private readonly logger;
-    private readonly stripe;
-    private readonly plans;
-    private readonly webhookSecret;
-    constructor(config: StripeConfig, plans?: PlanDefinition[], logger?: MiniLogger);
-    createCustomer(params: CreateCustomerParams): Promise<string>;
-    createCheckoutSession(params: CreateCheckoutParams): Promise<CheckoutSession>;
-    createSubscription(params: CreateSubscriptionParams): Promise<SubscriptionResult>;
-    cancelSubscription(subscriptionId: string, atPeriodEnd?: boolean): Promise<void>;
-    getSubscription(subscriptionId: string): Promise<SubscriptionResult & {
-        status: string;
-    }>;
-    getPortalUrl(customerId: string, returnUrl: string): Promise<string>;
-    handleWebhook(payload: Buffer, signature: string): Promise<WebhookEvent>;
-    getStripeInstance(): Stripe;
-}
-export {};