@agentfield/sdk 0.1.70-rc.1 → 0.1.70-rc.3

package/dist/index.d.ts

@@ -1569,6 +1569,138 @@ declare class MultimodalResponse {
  */
 declare function createMultimodalResponse(rawResponse: unknown, text?: string): MultimodalResponse;
 
+/**
+ * MediaProvider interface and MediaRouter for multi-provider media generation.
+ * Mirrors the Python SDK's MediaProvider abstraction.
+ */
+/** Custom error class for media provider failures with structured context. */
+declare class MediaProviderError extends Error {
+    readonly provider?: string;
+    readonly model?: string;
+    readonly endpoint?: string;
+    constructor(message: string, options?: {
+        provider?: string;
+        model?: string;
+        endpoint?: string;
+        cause?: unknown;
+    });
+}
+interface VideoRequest {
+    prompt: string;
+    model?: string;
+    duration?: number;
+    resolution?: '480p' | '720p' | '1080p' | '1K' | '2K' | '4K';
+    aspectRatio?: '16:9' | '9:16' | '1:1' | '4:3' | '3:4' | '21:9' | '9:21';
+    generateAudio?: boolean;
+    seed?: number;
+    frameImages?: Array<{
+        type: string;
+        imageUrl: {
+            url: string;
+        };
+        frameType?: string;
+    }>;
+    inputReferences?: Array<{
+        type: string;
+        imageUrl: {
+            url: string;
+        };
+    }>;
+    pollInterval?: number;
+    timeout?: number;
+}
+interface ImageRequest {
+    prompt: string;
+    model?: string;
+    size?: string;
+    quality?: string;
+    imageConfig?: {
+        aspectRatio?: string;
+        imageSize?: string;
+        superResolutionReferences?: string[];
+        fontInputs?: Array<{
+            fontUrl: string;
+            text: string;
+        }>;
+    };
+}
+interface AudioRequest {
+    text: string;
+    model?: string;
+    voice?: string;
+    format?: string;
+}
+interface MediaResponse {
+    text: string;
+    images: Array<{
+        url?: string;
+        b64Json?: string;
+        revisedPrompt?: string;
+    }>;
+    audio: {
+        data?: string;
+        format: string;
+        url?: string;
+    } | null;
+    files: Array<{
+        url?: string;
+        data?: string;
+        mimeType?: string;
+        filename?: string;
+    }>;
+    videos: Array<{
+        url?: string;
+        data?: string;
+        mimeType?: string;
+        filename?: string;
+        duration?: number;
+        resolution?: string;
+        aspectRatio?: string;
+        hasAudio?: boolean;
+        costUsd?: number;
+    }>;
+    rawResponse: unknown;
+}
+interface MediaProvider {
+    readonly name: string;
+    readonly supportedModalities: string[];
+    generateImage(request: ImageRequest): Promise<MediaResponse>;
+    generateAudio(request: AudioRequest): Promise<MediaResponse>;
+    generateVideo(request: VideoRequest): Promise<MediaResponse>;
+}
+/**
+ * Prefix-based media provider router.
+ * Resolves model strings to providers by longest-prefix match.
+ */
+declare class MediaRouter {
+    private providers;
+    register(prefix: string, provider: MediaProvider): void;
+    resolve(model: string, capability: string): MediaProvider;
+}
+
+/**
+ * OpenRouter-backed MediaProvider implementation.
+ * Supports video generation (async job), image generation, and audio generation via SSE.
+ */
+
+interface OpenRouterMediaProviderOptions {
+    apiKey?: string;
+    baseUrl?: string;
+}
+declare class OpenRouterMediaProvider implements MediaProvider {
+    readonly name = "openrouter";
+    readonly supportedModalities: string[];
+    private readonly baseUrl;
+    constructor(options?: OpenRouterMediaProviderOptions);
+    /** Prevent API key from leaking via JSON.stringify (CR-03). */
+    toJSON(): Record<string, unknown>;
+    generateVideo(request: VideoRequest): Promise<MediaResponse>;
+    generateImage(request: ImageRequest): Promise<MediaResponse>;
+    generateAudio(request: AudioRequest): Promise<MediaResponse>;
+    private post;
+    private get;
+}
+
 declare const SUPPORTED_PROVIDERS: Set<string>;
 declare function buildProvider(config: HarnessConfig): Promise<HarnessProvider>;
 
@@ -1676,4 +1808,4 @@ declare class ApprovalClient {
     waitForApproval(executionId: string, opts?: WaitForApprovalOptions): Promise<ApprovalStatusResponse>;
 }
 
-export { ACTIVE_STATUSES, AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, type AIToolRequestOptions, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, ApprovalClient, type ApprovalRequestResponse, type ApprovalStatusResponse, Audio, type AudioOutput, type AuditTrailExport, type AuditTrailFilters, type Awaitable, CANONICAL_STATUSES, type CompactCapability, type CompactDiscoveryResponse, DIDAuthenticator, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionLogAttributes, type ExecutionLogBatchPayload, type ExecutionLogContext, type ExecutionLogEmitOptions, type ExecutionLogEntry, type ExecutionLogLevel, type ExecutionLogTransport, type ExecutionLogTransportPayload, type ExecutionLogWireEntry, ExecutionLogger, type ExecutionLoggerOptions, type ExecutionMetadata, ExecutionStatus, type ExecutionStatusValue, File, type FileOutput, type GenerateCredentialOptions, type GenerateCredentialParams, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, type HarnessConfig, type HarnessOptions, type HarnessProvider, type HarnessResult, HarnessRunner, type HealthStatus, Image, type ImageOutput, type MemoryChangeEvent, MemoryClient, MemoryClientBase, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, type MemoryEventHistoryOptions, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, type Metrics, type MultimodalContent, MultimodalResponse, RateLimitError, type RateLimiterOptions, type RawExecutionContext, type RawResult, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type RequestApprovalPayload, SUPPORTED_PROVIDERS, type ServerlessAdapter, type ServerlessEvent, type ServerlessResponse, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, TERMINAL_STATUSES, Text, type ToolCallConfig, type ToolCallRecord, type ToolCallTrace, type ToolsOption, type VectorSearchOptions, type VectorSearchResult, type WaitForApprovalOptions, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, type ZodSchema, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, executeToolCallLoop, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeStatus, serializeExecutionLogEntry, text };
+export { ACTIVE_STATUSES, AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, type AIToolRequestOptions, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, ApprovalClient, type ApprovalRequestResponse, type ApprovalStatusResponse, Audio, type AudioOutput, type AudioRequest, type AuditTrailExport, type AuditTrailFilters, type Awaitable, CANONICAL_STATUSES, type CompactCapability, type CompactDiscoveryResponse, DIDAuthenticator, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionLogAttributes, type ExecutionLogBatchPayload, type ExecutionLogContext, type ExecutionLogEmitOptions, type ExecutionLogEntry, type ExecutionLogLevel, type ExecutionLogTransport, type ExecutionLogTransportPayload, type ExecutionLogWireEntry, ExecutionLogger, type ExecutionLoggerOptions, type ExecutionMetadata, ExecutionStatus, type ExecutionStatusValue, File, type FileOutput, type GenerateCredentialOptions, type GenerateCredentialParams, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, type HarnessConfig, type HarnessOptions, type HarnessProvider, type HarnessResult, HarnessRunner, type HealthStatus, Image, type ImageOutput, type ImageRequest, type MediaProvider, MediaProviderError, type MediaResponse, MediaRouter, type MemoryChangeEvent, MemoryClient, MemoryClientBase, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, type MemoryEventHistoryOptions, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, type Metrics, type MultimodalContent, MultimodalResponse, OpenRouterMediaProvider, type OpenRouterMediaProviderOptions, RateLimitError, type RateLimiterOptions, type RawExecutionContext, type RawResult, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type RequestApprovalPayload, SUPPORTED_PROVIDERS, type ServerlessAdapter, type ServerlessEvent, type ServerlessResponse, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, TERMINAL_STATUSES, Text, type ToolCallConfig, type ToolCallRecord, type ToolCallTrace, type ToolsOption, type VectorSearchOptions, type VectorSearchResult, type VideoRequest, type WaitForApprovalOptions, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, type ZodSchema, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, executeToolCallLoop, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeStatus, serializeExecutionLogEntry, text };

package/dist/index.js

@@ -5382,6 +5382,380 @@ function extractSingleFile(data) {
   return null;
 }
 
+// src/ai/MediaProvider.ts
+var MediaProviderError = class extends Error {
+  provider;
+  model;
+  endpoint;
+  constructor(message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = "MediaProviderError";
+    this.provider = options?.provider;
+    this.model = options?.model;
+    this.endpoint = options?.endpoint;
+  }
+};
+var MediaRouter = class {
+  providers = [];
+  register(prefix, provider) {
+    this.providers.push({ prefix, provider });
+    this.providers.sort((a, b) => b.prefix.length - a.prefix.length);
+  }
+  resolve(model, capability) {
+    for (const { prefix, provider } of this.providers) {
+      if (model.startsWith(prefix) && provider.supportedModalities.includes(capability)) {
+        return provider;
+      }
+    }
+    throw new MediaProviderError(
+      `No provider for model '${model}' with '${capability}' capability`,
+      { model }
+    );
+  }
+};
+
+// src/ai/OpenRouterMediaProvider.ts
+var OPENROUTER_BASE = "https://openrouter.ai/api/v1";
+var DEFAULT_POLL_INTERVAL = 3e4;
+var DEFAULT_TIMEOUT = 6e5;
+var API_TIMEOUT = 3e4;
+var DOWNLOAD_TIMEOUT = 12e4;
+var MAX_CONSECUTIVE_PARSE_ERRORS = 50;
+var apiKeyStore = /* @__PURE__ */ new WeakMap();
+function emptyMediaResponse(raw) {
+  return { text: "", images: [], audio: null, files: [], videos: [], rawResponse: raw };
+}
+function stripPrefix(model) {
+  return model.startsWith("openrouter/") ? model.slice("openrouter/".length) : model;
+}
+function assertSafeUrl(urlStr) {
+  let parsed;
+  try {
+    parsed = new URL(urlStr);
+  } catch {
+    throw new MediaProviderError(`Invalid download URL: ${urlStr}`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new MediaProviderError(
+      `Refusing to download from non-HTTPS URL: ${urlStr}`
+    );
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1" || host === "0.0.0.0") {
+    throw new MediaProviderError(`Refusing to download from localhost: ${urlStr}`);
+  }
+  const ipv4Match = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (ipv4Match) {
+    const [, a, b] = ipv4Match.map(Number);
+    if (a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254 || a === 0) {
+      throw new MediaProviderError(
+        `Refusing to download from private IP: ${urlStr}`
+      );
+    }
+  }
+}
+var OpenRouterMediaProvider = class {
+  name = "openrouter";
+  supportedModalities = ["image", "audio", "video"];
+  baseUrl;
+  constructor(options = {}) {
+    const key = options.apiKey ?? process.env.OPENROUTER_API_KEY ?? "";
+    this.baseUrl = options.baseUrl ?? OPENROUTER_BASE;
+    if (!key) {
+      throw new MediaProviderError("OpenRouter API key required: pass apiKey or set OPENROUTER_API_KEY", {
+        provider: "openrouter"
+      });
+    }
+    apiKeyStore.set(this, key);
+  }
+  /** Prevent API key from leaking via JSON.stringify (CR-03). */
+  toJSON() {
+    return {
+      name: this.name,
+      supportedModalities: this.supportedModalities,
+      baseUrl: this.baseUrl
+    };
+  }
+  // ── Video ──────────────────────────────────────────────────────────
+  async generateVideo(request) {
+    const model = stripPrefix(request.model ?? "google/veo-3");
+    const pollInterval = request.pollInterval ?? DEFAULT_POLL_INTERVAL;
+    const timeout = request.timeout ?? DEFAULT_TIMEOUT;
+    const body = {
+      model,
+      prompt: request.prompt
+    };
+    if (request.duration != null) body.duration = request.duration;
+    if (request.resolution) body.resolution = request.resolution;
+    if (request.aspectRatio) body.aspect_ratio = request.aspectRatio;
+    if (request.generateAudio != null) body.generate_audio = request.generateAudio;
+    if (request.seed != null) body.seed = request.seed;
+    if (request.frameImages) body.frame_images = request.frameImages;
+    if (request.inputReferences) body.input_references = request.inputReferences;
+    const submitEndpoint = `${this.baseUrl}/videos`;
+    const submitRes = await this.post(submitEndpoint, body);
+    if (!submitRes.ok) {
+      throw new MediaProviderError(
+        `Video submit failed [model=${model}] [endpoint=${submitEndpoint}]: ${submitRes.status} ${await submitRes.text()}`,
+        { provider: "openrouter", model, endpoint: submitEndpoint }
+      );
+    }
+    const submitData = await submitRes.json();
+    const jobId = submitData.id;
+    if (!jobId) {
+      throw new MediaProviderError("No job id returned from video submit", {
+        provider: "openrouter",
+        model,
+        endpoint: submitEndpoint
+      });
+    }
+    const deadline = Date.now() + timeout;
+    let jobData = {};
+    const pollEndpoint = `${this.baseUrl}/videos/${jobId}`;
+    while (true) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await sleep(Math.min(pollInterval, remaining));
+      if (Date.now() >= deadline) break;
+      const pollRes = await this.get(pollEndpoint);
+      if (!pollRes.ok) {
+        throw new MediaProviderError(
+          `Video poll failed [model=${model}] [endpoint=${pollEndpoint}]: ${pollRes.status} ${await pollRes.text()}`,
+          { provider: "openrouter", model, endpoint: pollEndpoint }
+        );
+      }
+      jobData = await pollRes.json();
+      const status = jobData.status;
+      if (status === "completed") break;
+      if (status === "failed" || status === "error") {
+        throw new MediaProviderError(
+          `Video generation failed [model=${model}]: ${JSON.stringify(jobData)}`,
+          { provider: "openrouter", model }
+        );
+      }
+    }
+    if (jobData.status !== "completed") {
+      throw new MediaProviderError(
+        `Video generation timed out [model=${model}] after ${timeout}ms`,
+        { provider: "openrouter", model }
+      );
+    }
+    const unsignedUrl = jobData.unsigned_url;
+    const signedUrl = jobData.url;
+    const videoUrl = unsignedUrl ?? signedUrl;
+    let videoData;
+    if (videoUrl) {
+      assertSafeUrl(videoUrl);
+      const dlRes = await fetch(videoUrl, {
+        signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT),
+        redirect: "error"
+      });
+      if (dlRes.ok) {
+        const buf = Buffer.from(await dlRes.arrayBuffer());
+        videoData = buf.toString("base64");
+      }
+    }
+    const resp = emptyMediaResponse(jobData);
+    resp.videos.push({
+      url: videoUrl,
+      data: videoData,
+      mimeType: "video/mp4",
+      duration: request.duration,
+      resolution: request.resolution,
+      aspectRatio: request.aspectRatio,
+      hasAudio: request.generateAudio,
+      costUsd: jobData.cost_usd
+    });
+    return resp;
+  }
+  // ── Image ──────────────────────────────────────────────────────────
+  async generateImage(request) {
+    const model = stripPrefix(request.model ?? "openai/gpt-image-1");
+    const messages = [{ role: "user", content: request.prompt }];
+    const body = {
+      model,
+      messages,
+      modalities: ["image", "text"]
+    };
+    if (request.size) body.size = request.size;
+    if (request.quality) body.quality = request.quality;
+    if (request.imageConfig) body.image_config = request.imageConfig;
+    const endpoint = `${this.baseUrl}/chat/completions`;
+    const res = await this.post(endpoint, body);
+    if (!res.ok) {
+      throw new MediaProviderError(
+        `Image generation failed [model=${model}] [endpoint=${endpoint}]: ${res.status} ${await res.text()}`,
+        { provider: "openrouter", model, endpoint }
+      );
+    }
+    const data = await res.json();
+    const resp = emptyMediaResponse(data);
+    const choices = data.choices;
+    if (choices) {
+      for (const choice of choices) {
+        const msg = choice.message;
+        if (!msg) continue;
+        if (typeof msg.content === "string") {
+          resp.text += msg.content;
+        }
+        if (Array.isArray(msg.content)) {
+          for (const part of msg.content) {
+            const p = part;
+            if (p.type === "text") {
+              resp.text += p.text;
+            } else if (p.type === "image_url") {
+              const imgUrl = p.image_url;
+              const url = imgUrl?.url;
+              if (url?.startsWith("data:")) {
+                const b64 = url.split(",", 2)[1];
+                resp.images.push({ url, b64Json: b64 });
+              } else if (url) {
+                resp.images.push({ url });
+              }
+            }
+          }
+        }
+      }
+    }
+    return resp;
+  }
+  // ── Audio ──────────────────────────────────────────────────────────
+  async generateAudio(request) {
+    const model = stripPrefix(request.model ?? "openai/gpt-4o-mini-tts");
+    const messages = [{ role: "user", content: request.text }];
+    const body = {
+      model,
+      messages,
+      modalities: ["text", "audio"],
+      stream: true,
+      audio: {
+        voice: request.voice ?? "alloy",
+        format: request.format ?? "wav"
+      }
+    };
+    const endpoint = `${this.baseUrl}/chat/completions`;
+    const res = await this.post(endpoint, body);
+    if (!res.ok) {
+      throw new MediaProviderError(
+        `Audio generation failed [model=${model}] [endpoint=${endpoint}]: ${res.status} ${await res.text()}`,
+        { provider: "openrouter", model, endpoint }
+      );
+    }
+    const audioChunks = [];
+    let textContent = "";
+    const reader = res.body?.getReader();
+    if (!reader) {
+      throw new MediaProviderError("No response body stream available", {
+        provider: "openrouter",
+        model,
+        endpoint
+      });
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let consecutiveParseErrors = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) continue;
+        const payload = trimmed.slice(5).trim();
+        if (payload === "[DONE]") continue;
+        try {
+          const chunk = JSON.parse(payload);
+          consecutiveParseErrors = 0;
+          const choices = chunk.choices;
+          if (!choices) continue;
+          for (const choice of choices) {
+            const delta = choice.delta;
+            if (!delta) continue;
+            if (typeof delta.content === "string") {
+              textContent += delta.content;
+            }
+            const audioDelta = delta.audio;
+            if (audioDelta?.data) {
+              audioChunks.push(audioDelta.data);
+            }
+          }
+        } catch {
+          consecutiveParseErrors++;
+          if (consecutiveParseErrors > MAX_CONSECUTIVE_PARSE_ERRORS) {
+            throw new MediaProviderError(
+              `Too many consecutive SSE parse errors (>${MAX_CONSECUTIVE_PARSE_ERRORS}) [model=${model}]`,
+              { provider: "openrouter", model, endpoint }
+            );
+          }
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const remaining = buffer.trim();
+      if (remaining.startsWith("data:")) {
+        const payload = remaining.slice(5).trim();
+        if (payload && payload !== "[DONE]") {
+          try {
+            const chunk = JSON.parse(payload);
+            const choices = chunk.choices;
+            if (choices) {
+              for (const choice of choices) {
+                const delta = choice.delta;
+                if (!delta) continue;
+                if (typeof delta.content === "string") {
+                  textContent += delta.content;
+                }
+                const audioDelta = delta.audio;
+                if (audioDelta?.data) {
+                  audioChunks.push(audioDelta.data);
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    const resp = emptyMediaResponse(null);
+    resp.text = textContent;
+    if (audioChunks.length > 0) {
+      resp.audio = {
+        data: audioChunks.join(""),
+        format: request.format ?? "wav"
+      };
+    }
+    return resp;
+  }
+  // ── Helpers ────────────────────────────────────────────────────────
+  post(url, body) {
+    const key = apiKeyStore.get(this);
+    return fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(API_TIMEOUT)
+    });
+  }
+  get(url) {
+    const key = apiKeyStore.get(this);
+    return fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${key}`
+      },
+      signal: AbortSignal.timeout(API_TIMEOUT)
+    });
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
 // src/harness/index.ts
 init_types();
 init_factory();
@@ -5527,7 +5901,7 @@ var ApprovalClient = class {
           `Approval for execution ${executionId} timed out after ${timeout}ms`
         );
       }
-      await sleep(interval);
+      await sleep2(interval);
       let data;
       try {
         data = await this.getApprovalStatus(executionId);
@@ -5542,10 +5916,10 @@ var ApprovalClient = class {
     }
   }
 };
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, Audio, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, Image, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, Text, WorkflowReporter, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, executeToolCallLoop, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeStatus, serializeExecutionLogEntry, text };
+export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, Audio, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, Image, MediaProviderError, MediaRouter, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, OpenRouterMediaProvider, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, Text, WorkflowReporter, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, executeToolCallLoop, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeStatus, serializeExecutionLogEntry, text };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map