@jini-ai/agent-runtime 0.3.9 → 0.4.0

package/dist/providers/pkce.d.ts

@@ -25,8 +25,11 @@ export interface PendingAuthState {
     resource?: string;
     createdAt: number;
 }
+/** RFC 7636 §4.1 permits 43–128 verifier characters; 64 random bytes encode to 86. */
 export declare function generateCodeVerifier(): string;
-export declare function deriveCodeChallenge(verifier: string): string;
+export declare function deriveCodeChallenge({ verifier }: {
+    verifier: string;
+}): string;
 export declare function generateState(): string;
 export interface AuthorizeUrlInput {
     authServer: AuthorizationServerMetadata;
@@ -37,7 +40,7 @@ export interface AuthorizeUrlInput {
     scope?: string;
     resource?: string;
 }
-export declare function buildAuthorizeUrl(input: AuthorizeUrlInput): string;
+export declare function buildAuthorizeUrl(requiredArgs: Pick<AuthorizeUrlInput, "authServer" | "clientId" | "redirectUri" | "state" | "codeChallenge">, optionalArgs?: Omit<AuthorizeUrlInput, "authServer" | "clientId" | "redirectUri" | "state" | "codeChallenge">): string;
 export interface ExchangeCodeInput {
     tokenEndpoint: string;
     clientId: string;
@@ -47,7 +50,11 @@ export interface ExchangeCodeInput {
     codeVerifier: string;
     resource?: string;
 }
-export declare function exchangeCodeForToken(input: ExchangeCodeInput, fetchImpl?: typeof fetch): Promise<OAuthTokenResponse>;
+export declare function exchangeCodeForToken({ input }: {
+    input: ExchangeCodeInput;
+}, { fetchImpl }?: {
+    fetchImpl?: typeof fetch;
+}): Promise<OAuthTokenResponse>;
 export interface RefreshTokenInput {
     tokenEndpoint: string;
     clientId: string;
@@ -56,26 +63,32 @@ export interface RefreshTokenInput {
     scope?: string;
     resource?: string;
 }
-export declare function refreshAccessToken(input: RefreshTokenInput, fetchImpl?: typeof fetch): Promise<OAuthTokenResponse>;
-/**
- * In-memory pending-authorization cache keyed by the OAuth `state`
- * parameter. Bridges the "begin" (mint state + verifier) and "complete"
- * (browser returns code + state) halves of the dance; persistence isn't
- * needed because the caller completes auth in the same process, and state
- * is single-use.
+export declare function refreshAccessToken({ input }: {
+    input: RefreshTokenInput;
+}, { fetchImpl }?: {
+    fetchImpl?: typeof fetch;
+}): Promise<OAuthTokenResponse>;
+/** In-memory pending authorization keyed by the OAuth state parameter. Bridges the
+ * begin (mint state + verifier) and complete (browser returns code + state) halves.
+ * Persistence is not needed because the caller completes auth in the same process,
+ * and state is single-use. The host timer adapter retains unref and the synchronous
+ * cache contract while delegating storage and expiry to the main OAuth factory.
  */
 export declare class PendingAuthCache {
-    private readonly ttlMs;
-    private store;
-    private timer;
-    constructor(ttlMs?: number);
-    put(state: string, value: PendingAuthState): void;
-    /** One-shot consume — any successful callback removes the state so a replay can't reuse it. */
-    consume(state: string): PendingAuthState | null;
+    private readonly cache;
+    constructor(_requiredArgs?: Record<string, never>, { ttlMs }?: {
+        ttlMs?: number;
+    });
+    put({ state, value }: {
+        state: string;
+        value: PendingAuthState;
+    }): void;
+    /** One-shot consume removes state before returning so a callback replay cannot reuse it. */
+    consume({ state }: {
+        state: string;
+    }): PendingAuthState | null;
     size(): number;
-    /** Stops the background sweeper. Production lets the timer ride on the host process lifetime. */
+    /** Stops the background sweeper; its timer ownership belongs to the host scheduler. */
     stop(): void;
-    private startSweeper;
-    private sweep;
 }
 //# sourceMappingURL=pkce.d.ts.map

package/dist/providers/pkce.js

@@ -1,11 +1,11 @@
 /**
  * @module providers/pkce
  *
- * Generic OAuth 2.0 Authorization Code + PKCE (RFC 7636) client primitives —
+ * Fixed-issuer OAuth 2.0 Authorization Code + PKCE (RFC 7636) provider adapters —
  * verifier/challenge/state generation, authorize-URL building, and the
  * code-exchange/refresh token-endpoint calls.
  *
- * Vendored from the minimal subset of OD's `apps/daemon/src/mcp-oauth.ts`
+ * Originally vendored from the minimal subset of OD's `apps/daemon/src/mcp-oauth.ts`
  * (a 601-line "daemon-side OAuth 2.1 client for HTTP/SSE MCP servers") that
  * `integrations/xai-oauth.ts` actually depends on: PKCE generation,
  * `buildAuthorizeUrl`, `exchangeCodeForToken`, `refreshAccessToken`, and the
@@ -19,158 +19,87 @@
  * ported, mirroring the same reasoning `@jini-ai/agent-runtime`'s
  * `acp-model-probe.ts` used to exclude the ACP transport (a distinct
  * subsystem named as its own future extraction target). No product-identity
- * strings in the vendored subset — ported verbatim apart from doc-comment
- * wording.
+ * strings in the vendored subset. Protocol implementation now lives in
+ * `@jini-ai/oauth`; this module retains the provider DTO and synchronous callback adapter.
+ * The historical split still explains why discovery and dynamic registration do not
+ * belong in this fixed-issuer bridge.
  */
-import { createHash, randomBytes } from 'node:crypto';
-const VERIFIER_LEN = 64; // RFC 7636 §4.1: 43-128 chars
-function base64url(buf) {
-    return buf
-        .toString('base64')
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=+$/g, '');
+import { randomBytes } from 'node:crypto';
+import { createPkcePair, deriveCodeChallenge as deriveOAuthCodeChallenge, generateOAuthState, buildOAuthAuthorizationUrl, exchangeOAuthAuthorizationCode, refreshAccessToken as refreshOAuthAccessToken, createPendingAuthorizationStore, createOAuthUrlGuard, } from '@jini-ai/oauth';
+const entropy = ({ byteLength }) => randomBytes(byteLength);
+/** RFC 7636 §4.1 permits 43–128 verifier characters; 64 random bytes encode to 86. */
+export function generateCodeVerifier() { return createPkcePair({ randomBytesFn: entropy }, { verifierBytes: 64 }).codeVerifier; }
+export function deriveCodeChallenge({ verifier }) { return deriveOAuthCodeChallenge({ codeVerifier: verifier }); }
+export function generateState() { return generateOAuthState({ randomBytesFn: entropy }); }
+export function buildAuthorizeUrl(requiredArgs, optionalArgs = {}) {
+    return buildOAuthAuthorizationUrl({
+        authorizationEndpoint: requiredArgs.authServer.authorization_endpoint,
+        clientId: requiredArgs.clientId, redirectUri: requiredArgs.redirectUri,
+        state: requiredArgs.state, codeChallenge: requiredArgs.codeChallenge,
+    }, optionalArgs);
 }
-export function generateCodeVerifier() {
-    return base64url(randomBytes(VERIFIER_LEN));
+export async function exchangeCodeForToken({ input }, { fetchImpl = fetch } = {}) {
+    let issuedAtMs = 0;
+    const tokenClock = { nowMs: () => (issuedAtMs = Date.now()) };
+    const tokens = await exchangeOAuthAuthorizationCode({
+        fetchFn: ({ url }, init) => fetchImpl(url, init), guard, clock: tokenClock,
+        tokenEndpoint: input.tokenEndpoint, client: clientFor(input),
+        redirectUri: input.redirectUri, code: input.code, codeVerifier: input.codeVerifier,
+    }, input.resource === undefined ? {} : { resource: input.resource });
+    return persistedWireTokens({ tokens, issuedAtMs });
 }
-export function deriveCodeChallenge(verifier) {
-    return base64url(createHash('sha256').update(verifier).digest());
+export async function refreshAccessToken({ input }, { fetchImpl = fetch } = {}) {
+    let issuedAtMs = 0;
+    const tokenClock = { nowMs: () => (issuedAtMs = Date.now()) };
+    const tokens = await refreshOAuthAccessToken({
+        fetchFn: ({ url }, init) => fetchImpl(url, init), guard, clock: tokenClock,
+        tokenEndpoint: input.tokenEndpoint, client: clientFor(input), refreshToken: input.refreshToken,
+    }, { ...(input.scope === undefined ? {} : { scopes: input.scope.split(/\s+/).filter(Boolean) }),
+        ...(input.resource === undefined ? {} : { resource: input.resource }) });
+    return persistedWireTokens({ tokens, issuedAtMs });
 }
-export function generateState() {
-    return base64url(randomBytes(32));
+const clock = { nowMs: () => Date.now() };
+// Fixed-issuer provider definitions supply endpoints; the shared scheme gate
+// still refuses plaintext except for explicitly allowed local authorization servers.
+const guard = createOAuthUrlGuard({ assertAllowed: () => undefined }, { allowLoopbackHttp: true });
+function clientFor(input) {
+    return input.clientSecret
+        ? { clientId: input.clientId, clientSecret: input.clientSecret, authMethod: 'client_secret_basic' }
+        : { clientId: input.clientId, authMethod: 'none' };
 }
-export function buildAuthorizeUrl(input) {
-    const u = new URL(input.authServer.authorization_endpoint);
-    u.searchParams.set('response_type', 'code');
-    u.searchParams.set('client_id', input.clientId);
-    u.searchParams.set('redirect_uri', input.redirectUri);
-    u.searchParams.set('state', input.state);
-    u.searchParams.set('code_challenge', input.codeChallenge);
-    u.searchParams.set('code_challenge_method', 'S256');
-    if (input.scope)
-        u.searchParams.set('scope', input.scope);
-    // RFC 8707 resource indicator — narrows the issued token to the resource
-    // actually being requested. Most authoritative servers require it;
-    // harmless when ignored.
-    if (input.resource)
-        u.searchParams.set('resource', input.resource);
-    return u.toString();
+/** Persistence keeps the provider adapter's existing snake_case format; parsing is OAuth-owned. */
+function persistedWireTokens({ tokens, issuedAtMs }) {
+    return { access_token: tokens.accessToken, token_type: tokens.tokenType,
+        ...(tokens.refreshToken === null ? {} : { refresh_token: tokens.refreshToken }),
+        ...(tokens.expiresAt === null ? {} : { expires_in: Math.max(0, (Date.parse(tokens.expiresAt) - issuedAtMs) / 1000) }),
+        ...(tokens.scopes.length === 0 ? {} : { scope: tokens.scopes.join(' ') }) };
 }
-export async function exchangeCodeForToken(input, fetchImpl = fetch) {
-    const form = new URLSearchParams();
-    form.set('grant_type', 'authorization_code');
-    form.set('code', input.code);
-    form.set('redirect_uri', input.redirectUri);
-    form.set('client_id', input.clientId);
-    form.set('code_verifier', input.codeVerifier);
-    if (input.resource)
-        form.set('resource', input.resource);
-    return tokenRequest(input.tokenEndpoint, form, input.clientSecret, fetchImpl);
-}
-export async function refreshAccessToken(input, fetchImpl = fetch) {
-    const form = new URLSearchParams();
-    form.set('grant_type', 'refresh_token');
-    form.set('refresh_token', input.refreshToken);
-    form.set('client_id', input.clientId);
-    if (input.scope)
-        form.set('scope', input.scope);
-    if (input.resource)
-        form.set('resource', input.resource);
-    return tokenRequest(input.tokenEndpoint, form, input.clientSecret, fetchImpl);
-}
-async function tokenRequest(tokenEndpoint, form, clientSecret, fetchImpl) {
-    const headers = {
-        'content-type': 'application/x-www-form-urlencoded',
-        accept: 'application/json',
-    };
-    if (clientSecret) {
-        // RFC 6749 §2.3.1 — confidential clients use HTTP Basic with the
-        // client_id already in the form. Public clients (PKCE-only) skip this.
-        const basic = Buffer.from(`${form.get('client_id')}:${clientSecret}`).toString('base64');
-        headers['authorization'] = `Basic ${basic}`;
-    }
-    const res = await fetchImpl(tokenEndpoint, {
-        method: 'POST',
-        headers,
-        body: form.toString(),
-    });
-    if (!res.ok) {
-        const txt = await safeText(res);
-        throw new Error(`token endpoint rejected request: HTTP ${res.status} ${res.statusText} ${txt}`);
-    }
-    const json = (await res.json());
-    if (!json.access_token) {
-        throw new Error('token endpoint response missing access_token');
-    }
-    return json;
-}
-async function safeText(res) {
-    try {
-        const t = await res.text();
-        return t.slice(0, 500);
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * In-memory pending-authorization cache keyed by the OAuth `state`
- * parameter. Bridges the "begin" (mint state + verifier) and "complete"
- * (browser returns code + state) halves of the dance; persistence isn't
- * needed because the caller completes auth in the same process, and state
- * is single-use.
+/** In-memory pending authorization keyed by the OAuth state parameter. Bridges the
+ * begin (mint state + verifier) and complete (browser returns code + state) halves.
+ * Persistence is not needed because the caller completes auth in the same process,
+ * and state is single-use. The host timer adapter retains unref and the synchronous
+ * cache contract while delegating storage and expiry to the main OAuth factory.
  */
 export class PendingAuthCache {
-    ttlMs;
-    store = new Map();
-    timer = null;
-    constructor(ttlMs = 10 * 60 * 1000) {
-        this.ttlMs = ttlMs;
-    }
-    put(state, value) {
-        this.store.set(state, value);
-        this.startSweeper();
-    }
-    /** One-shot consume — any successful callback removes the state so a replay can't reuse it. */
-    consume(state) {
-        const v = this.store.get(state);
-        if (!v)
-            return null;
-        this.store.delete(state);
-        if (Date.now() - v.createdAt > this.ttlMs)
-            return null;
-        return v;
-    }
-    size() {
-        return this.store.size;
-    }
-    /** Stops the background sweeper. Production lets the timer ride on the host process lifetime. */
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    startSweeper() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => this.sweep(), Math.min(this.ttlMs, 60_000));
-        // unref so the cache doesn't keep the event loop alive in tests.
-        if (typeof this.timer === 'object' && this.timer && typeof this.timer.unref === 'function') {
-            this.timer.unref();
-        }
-    }
-    sweep() {
-        const now = Date.now();
-        for (const [k, v] of this.store) {
-            if (now - v.createdAt > this.ttlMs)
-                this.store.delete(k);
-        }
-        if (this.store.size === 0 && this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
+    cache;
+    constructor(_requiredArgs = {}, { ttlMs = 10 * 60 * 1000 } = {}) {
+        this.cache = createPendingAuthorizationStore({ clock }, {
+            ttlMs, expiry: ({ value, ttlMs }) => value.createdAt + ttlMs, exclusiveExpiry: true,
+            scheduler: {
+                every: ({ intervalMs, run }) => {
+                    const timer = setInterval(run, intervalMs);
+                    // Pending browser authorization must not keep an otherwise idle host process alive.
+                    timer.unref();
+                    return () => clearInterval(timer);
+                },
+            },
+        });
     }
+    put({ state, value }) { this.cache.put({ state, value }); }
+    /** One-shot consume removes state before returning so a callback replay cannot reuse it. */
+    consume({ state }) { return this.cache.consume({ state }); }
+    size() { return this.cache.size({}); }
+    /** Stops the background sweeper; its timer ownership belongs to the host scheduler. */
+    stop() { this.cache.stop({}); }
 }
 //# sourceMappingURL=pkce.js.map

package/dist/providers/sse-decode.d.ts

@@ -43,5 +43,7 @@ export interface DecodedSseEvent {
  * source iterable ends, so a provider closing the connection immediately
  * after its last byte never silently loses that last record.
  */
-export declare function decodeSseStream(source: AsyncIterable<Uint8Array | string>): AsyncGenerator<DecodedSseEvent>;
+export declare function decodeSseStream({ source }: {
+    source: AsyncIterable<Uint8Array | string>;
+}): AsyncGenerator<DecodedSseEvent>;
 //# sourceMappingURL=sse-decode.d.ts.map

package/dist/providers/sse-decode.js

@@ -38,7 +38,7 @@
  * source iterable ends, so a provider closing the connection immediately
  * after its last byte never silently loses that last record.
  */
-export async function* decodeSseStream(source) {
+export async function* decodeSseStream({ source }) {
     const decoder = new TextDecoder();
     let buffer = '';
     let eventType = null;

package/dist/providers/token-params.d.ts

@@ -9,21 +9,32 @@
  * origin — ported verbatim.
  */
 /** True when `model` belongs to a family that rejects the legacy `max_tokens` field. */
-export declare function usesMaxCompletionTokens(model: string): boolean;
+export declare function usesMaxCompletionTokens({ model }: {
+    model: string;
+}): boolean;
 /** Selects `max_tokens` or `max_completion_tokens` per {@link usesMaxCompletionTokens}. */
-export declare function buildOpenAIChatTokenParam(model: string, maxTokens: number): {
+export declare function buildOpenAIChatTokenParam({ model, maxTokens }: {
+    model: string;
+    maxTokens: number;
+}): {
     max_tokens: number;
 } | {
     max_completion_tokens: number;
 };
 /** Always the legacy `max_tokens` shape — for callers that already know the model family. */
-export declare function buildLegacyMaxTokensParam(maxTokens: number): {
+export declare function buildLegacyMaxTokensParam({ maxTokens }: {
+    maxTokens: number;
+}): {
     max_tokens: number;
 };
 /** Always the newer `max_completion_tokens` shape — for callers that already know the model family. */
-export declare function buildMaxCompletionTokensParam(maxTokens: number): {
+export declare function buildMaxCompletionTokensParam({ maxTokens }: {
+    maxTokens: number;
+}): {
     max_completion_tokens: number;
 };
 /** Detects the provider error text a gateway returns when `max_tokens` was rejected in favor of `max_completion_tokens`. */
-export declare function isUnsupportedMaxTokensError(detail: string): boolean;
+export declare function isUnsupportedMaxTokensError({ detail }: {
+    detail: string;
+}): boolean;
 //# sourceMappingURL=token-params.d.ts.map

package/dist/providers/token-params.js

@@ -9,7 +9,7 @@
  * origin — ported verbatim.
  */
 /** True when `model` belongs to a family that rejects the legacy `max_tokens` field. */
-export function usesMaxCompletionTokens(model) {
+export function usesMaxCompletionTokens({ model }) {
     const normalized = model.trim().toLowerCase();
     return (/^gpt-5(?:[.-]|$)/.test(normalized) ||
         /^o1(?:[.-]|$)/.test(normalized) ||
@@ -17,22 +17,22 @@ export function usesMaxCompletionTokens(model) {
         /^o4(?:[.-]|$)/.test(normalized));
 }
 /** Selects `max_tokens` or `max_completion_tokens` per {@link usesMaxCompletionTokens}. */
-export function buildOpenAIChatTokenParam(model, maxTokens) {
-    if (usesMaxCompletionTokens(model)) {
+export function buildOpenAIChatTokenParam({ model, maxTokens }) {
+    if (usesMaxCompletionTokens({ model: model })) {
         return { max_completion_tokens: maxTokens };
     }
     return { max_tokens: maxTokens };
 }
 /** Always the legacy `max_tokens` shape — for callers that already know the model family. */
-export function buildLegacyMaxTokensParam(maxTokens) {
+export function buildLegacyMaxTokensParam({ maxTokens }) {
     return { max_tokens: maxTokens };
 }
 /** Always the newer `max_completion_tokens` shape — for callers that already know the model family. */
-export function buildMaxCompletionTokensParam(maxTokens) {
+export function buildMaxCompletionTokensParam({ maxTokens }) {
     return { max_completion_tokens: maxTokens };
 }
 /** Detects the provider error text a gateway returns when `max_tokens` was rejected in favor of `max_completion_tokens`. */
-export function isUnsupportedMaxTokensError(detail) {
+export function isUnsupportedMaxTokensError({ detail }) {
     const normalized = detail.toLowerCase();
     return (normalized.includes('unsupported parameter') &&
         normalized.includes('max_tokens') &&

package/dist/providers/tool-turn-types.d.ts

@@ -0,0 +1,89 @@
+import type { runAnthropicToolTurn } from './anthropic-messages.js';
+import type { runOpenAiToolTurn } from './openai-chat.js';
+import type { runAzureToolTurn } from './azure-chat.js';
+import type { runGoogleToolTurn } from './google-messages.js';
+/** Adapter ports retain each existing provider's request and tool-loop contract. */
+export interface ProviderTurnAdapters {
+    readonly anthropic: typeof runAnthropicToolTurn;
+    readonly openai: typeof runOpenAiToolTurn;
+    readonly azure: typeof runAzureToolTurn;
+    readonly google: typeof runGoogleToolTurn;
+}
+/** Structural descriptors keep host registries out of the runtime dependency graph. */
+export interface ProviderToolDescriptor {
+    readonly id: string;
+    readonly description?: string;
+    readonly inputSchema?: unknown;
+}
+export type ProviderProtocol = "anthropic" | "openai" | "azure" | "google";
+export interface ProviderChatMessage {
+    readonly role: "user" | "assistant";
+    readonly content: string;
+}
+export type ProviderTurnEvent = {
+    readonly type: "status";
+    readonly label: string;
+} | {
+    readonly type: "text_delta";
+    readonly delta: string;
+} | {
+    readonly type: "tool_use";
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+} | {
+    readonly type: "tool_result";
+    readonly toolUseId: string;
+    readonly content: string;
+    readonly isError: boolean;
+} | {
+    readonly type: "usage";
+    readonly usage: Record<string, unknown> | null;
+} | {
+    readonly type: "error";
+    readonly message: string;
+} | {
+    readonly type: "end";
+    readonly reason: string;
+};
+export interface ProviderToolCall {
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+}
+export type ProviderToolResultBlock = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "image";
+    readonly mimeType: string;
+    readonly data: string;
+};
+export interface ProviderToolResult {
+    readonly content: string | readonly ProviderToolResultBlock[];
+    readonly isError?: boolean;
+}
+export type ProviderToolExecutor = (call: ProviderToolCall) => Promise<ProviderToolResult>;
+export interface ProviderToolTurnInput {
+    readonly protocol: ProviderProtocol;
+    readonly adapters: ProviderTurnAdapters;
+    readonly apiKey: string;
+    readonly model: string;
+    readonly system: string;
+    readonly messages: readonly ProviderChatMessage[];
+    readonly tools: readonly ProviderToolDescriptor[];
+    readonly executeTool: ProviderToolExecutor;
+    readonly onEvent: (event: ProviderTurnEvent) => void;
+}
+export interface ProviderToolTurnResult {
+    readonly stopReason: string | null;
+    readonly toolTurns: number;
+}
+/** Optional turn controls; dependencies belong in the required input object. */
+export interface ProviderToolTurnOptions {
+    readonly baseUrl?: string;
+    readonly maxTokens?: number;
+    readonly maxToolTurns?: number;
+    readonly signal?: AbortSignal;
+}
+//# sourceMappingURL=tool-turn-types.d.ts.map

package/dist/providers/tool-turn-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-turn-types.js.map

package/dist/providers/tool-turn.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderTurnAdapters, ProviderToolTurnInput, ProviderToolTurnResult, ProviderToolTurnOptions } from './tool-turn-types.js';
+export type * from './tool-turn-types.js';
+export { googleParametersOf, sanitizeGoogleSchema, findNumericEnumPaths, coerceNumericEnumStringsToNumbers } from './google-schema.js';
+/** Existing provider loops, ready for host composition; callers may replace any adapter. */
+export declare const providerTurnAdapters: ProviderTurnAdapters;
+/** Runs one provider-neutral turn through the supplied adapters. The adapter end event takes precedence over a raw provider stop code.
+ * Local mapping is proportional to the descriptors, expanded schemas and emitted result parts; request and loop cost belongs to the adapter ports.
+ */
+export declare function runProviderToolTurn(required: ProviderToolTurnInput, optional?: ProviderToolTurnOptions): Promise<ProviderToolTurnResult>;
+//# sourceMappingURL=tool-turn.d.ts.map