@perstack/runtime 0.0.71 → 0.0.72

package/dist/{chunk-LDJKVMQK.js → chunk-BXJGGA3Q.js}

@@ -12,17 +12,17 @@ import { createVertex } from '@ai-sdk/google-vertex';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { ProxyAgent, fetch } from 'undici';
-import { ApiV1Client } from '@perstack/api-client/v1';
+import { createApiClient } from '@perstack/api-client';
 import { setup, assign, createActor } from 'xstate';
 import { readFile } from 'fs/promises';
 import { createId } from '@paralleldrive/cuid2';
 import { dedent } from 'ts-dedent';
-import { generateText, streamText } from 'ai';
+import { APICallError, generateText, streamText } from 'ai';
 
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.71",
+  version: "0.0.72",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -63,18 +63,9 @@ var package_default = {
     "@ai-sdk/openai": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "@paralleldrive/cuid2": "^3.0.4",
-    "@perstack/anthropic-provider": "workspace:*",
     "@perstack/api-client": "workspace:*",
     "@perstack/base": "workspace:*",
-    "@perstack/azure-openai-provider": "workspace:*",
-    "@perstack/bedrock-provider": "workspace:*",
     "@perstack/core": "workspace:*",
-    "@perstack/deepseek-provider": "workspace:*",
-    "@perstack/google-provider": "workspace:*",
-    "@perstack/ollama-provider": "workspace:*",
-    "@perstack/openai-provider": "workspace:*",
-    "@perstack/provider-core": "workspace:*",
-    "@perstack/vertex-provider": "workspace:*",
     ai: "^5.0.115",
     "ollama-ai-provider-v2": "^1.5.5",
     commander: "^14.0.2",
@@ -345,12 +336,15 @@ async function resolveExpertToRun(expertKey, experts, clientOptions) {
   if (experts[expertKey]) {
     return experts[expertKey];
   }
-  const client = new ApiV1Client({
+  const client = createApiClient({
     baseUrl: clientOptions.perstackApiBaseUrl,
     apiKey: clientOptions.perstackApiKey
   });
-  const { expert } = await client.registry.experts.get({ expertKey });
-  return toRuntimeExpert(expert);
+  const result = await client.registry.experts.get(expertKey);
+  if (!result.ok) {
+    throw new Error(`Failed to resolve expert "${expertKey}": ${result.error.message}`);
+  }
+  return toRuntimeExpert(result.data);
 }
 function toRuntimeExpert(expert) {
   const skills = Object.fromEntries(
@@ -2276,40 +2270,1066 @@ async function createProviderAdapter(config, options) {
   pendingCreations.set(cacheKey, creationPromise);
   return creationPromise;
 }
+var BaseProviderAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  getProviderTools(_toolNames, _options) {
+    return {};
+  }
+  getProviderOptions(_config) {
+    return void 0;
+  }
+  getReasoningOptions(_budget) {
+    return void 0;
+  }
+  normalizeError(error) {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message,
+        isRetryable: this.isRetryable(error),
+        provider: this.providerName,
+        originalError: error
+      };
+    }
+    return {
+      name: "UnknownError",
+      message: String(error),
+      isRetryable: false,
+      provider: this.providerName,
+      originalError: error
+    };
+  }
+  isRetryable(error) {
+    if (error instanceof Error) {
+      const retryablePatterns = [
+        /rate limit/i,
+        /timeout/i,
+        /overloaded/i,
+        /service unavailable/i,
+        /internal server error/i,
+        /bad gateway/i,
+        /gateway timeout/i
+      ];
+      return retryablePatterns.some((pattern) => pattern.test(error.message));
+    }
+    return false;
+  }
+  createProxyFetch(proxyUrl) {
+    const agent = new ProxyAgent(proxyUrl);
+    return (input, init) => {
+      return fetch(input, { ...init, dispatcher: agent });
+    };
+  }
+};
+function normalizeAnthropicError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isAnthropicRetryable(error),
+      provider: "anthropic",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isAnthropicRetryable(error),
+      provider: "anthropic",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "anthropic",
+    originalError: error
+  };
+}
+function isAnthropicRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("overloaded")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/anthropic/src/skills.ts
+function convertSkill(skill) {
+  if (skill.type === "builtin") {
+    return {
+      type: "builtin",
+      name: skill.skillId
+    };
+  }
+  try {
+    return {
+      type: "custom",
+      name: skill.name,
+      mcp_config: JSON.parse(skill.definition)
+    };
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in custom skill definition for "${skill.name}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function buildProviderOptions(skills) {
+  if (!skills || skills.length === 0) {
+    return void 0;
+  }
+  return {
+    anthropic: {
+      container: {
+        skills: skills.map(convertSkill)
+      }
+    }
+  };
+}
+
+// ../../packages/providers/anthropic/src/tools.ts
+function buildAnthropicTools(client, toolNames, options) {
+  const tools = {};
+  for (const name of toolNames) {
+    switch (name) {
+      case "webSearch": {
+        const webSearchTool = client.tools.webSearch_20250305({
+          maxUses: options?.webSearch?.maxUses,
+          allowedDomains: options?.webSearch?.allowedDomains
+        });
+        tools["web_search"] = webSearchTool;
+        break;
+      }
+      case "webFetch": {
+        const webFetchTool = client.tools.webFetch_20250910({
+          maxUses: options?.webFetch?.maxUses
+        });
+        tools["web_fetch"] = webFetchTool;
+        break;
+      }
+      case "codeExecution": {
+        const codeExecutionTool = client.tools.codeExecution_20250522();
+        tools["code_execution"] = codeExecutionTool;
+        break;
+      }
+    }
+  }
+  return tools;
+}
+
+// ../../packages/providers/anthropic/src/adapter.ts
+var AnthropicProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createAnthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      headers: config.headers,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "anthropic";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderTools(toolNames, options) {
+    return buildAnthropicTools(this.client, toolNames, options);
+  }
+  getProviderOptions(config) {
+    return buildProviderOptions(config?.skills);
+  }
+  getReasoningOptions(budget) {
+    const budgetTokens = this.budgetToTokens(budget);
+    return {
+      anthropic: {
+        thinking: { type: "enabled", budgetTokens }
+      }
+    };
+  }
+  budgetToTokens(budget) {
+    if (typeof budget === "number") return budget;
+    const map = {
+      minimal: 1024,
+      low: 2048,
+      medium: 5e3,
+      high: 1e4
+    };
+    return map[budget] ?? 5e3;
+  }
+  normalizeError(error) {
+    return normalizeAnthropicError(error);
+  }
+  isRetryable(error) {
+    return isAnthropicRetryable(error);
+  }
+};
+function normalizeAzureOpenAIError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isAzureOpenAIRetryable(error),
+      provider: "azure-openai",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isAzureOpenAIRetryable(error),
+      provider: "azure-openai",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "azure-openai",
+    originalError: error
+  };
+}
+function isAzureOpenAIRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/azure-openai/src/tools.ts
+function buildAzureOpenAITools(client, toolNames, options) {
+  const tools = {};
+  for (const name of toolNames) {
+    switch (name) {
+      case "webSearchPreview": {
+        const webSearchTool = client.tools.webSearchPreview({});
+        tools["web_search_preview"] = webSearchTool;
+        break;
+      }
+      case "fileSearch": {
+        const vectorStoreIds = options?.fileSearch?.vectorStoreIds;
+        if (!vectorStoreIds || vectorStoreIds.length === 0) {
+          console.warn(
+            "Azure OpenAI fileSearch tool requires vectorStoreIds. Set providerToolOptions.fileSearch.vectorStoreIds to use this tool."
+          );
+          break;
+        }
+        const fileSearchTool = client.tools.fileSearch({
+          vectorStoreIds,
+          maxNumResults: options?.fileSearch?.maxNumResults
+        });
+        tools["file_search"] = fileSearchTool;
+        break;
+      }
+      case "codeInterpreter": {
+        const codeInterpreterTool = client.tools.codeInterpreter();
+        tools["code_interpreter"] = codeInterpreterTool;
+        break;
+      }
+      case "imageGeneration": {
+        const imageGenerationTool = client.tools.imageGeneration();
+        tools["image_generation"] = imageGenerationTool;
+        break;
+      }
+    }
+  }
+  return tools;
+}
+
+// ../../packages/providers/azure-openai/src/adapter.ts
+var AzureOpenAIProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createAzure({
+      apiKey: config.apiKey,
+      resourceName: config.resourceName,
+      apiVersion: config.apiVersion,
+      baseURL: config.baseUrl,
+      headers: config.headers,
+      useDeploymentBasedUrls: config.useDeploymentBasedUrls,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "azure-openai";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderTools(toolNames, options) {
+    return buildAzureOpenAITools(this.client, toolNames, options);
+  }
+  normalizeError(error) {
+    return normalizeAzureOpenAIError(error);
+  }
+  isRetryable(error) {
+    return isAzureOpenAIRetryable(error);
+  }
+};
+function normalizeBedrockError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isBedrockRetryable(error),
+      provider: "amazon-bedrock",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isBedrockRetryable(error),
+      provider: "amazon-bedrock",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "amazon-bedrock",
+    originalError: error
+  };
+}
+function isBedrockRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("throttl")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/bedrock/src/adapter.ts
+var BedrockProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createAmazonBedrock({
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey,
+      region: config.region,
+      sessionToken: config.sessionToken,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "amazon-bedrock";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderOptions(config) {
+    if (!config?.guardrails && !config?.cachePoint) {
+      return void 0;
+    }
+    const bedrockOptions = {};
+    if (config.guardrails) {
+      const guardrailConfig = {
+        guardrailIdentifier: config.guardrails.guardrailIdentifier,
+        guardrailVersion: config.guardrails.guardrailVersion
+      };
+      if (config.guardrails.trace) {
+        guardrailConfig["trace"] = config.guardrails.trace;
+      }
+      bedrockOptions["guardrailConfig"] = guardrailConfig;
+    }
+    if (config.cachePoint) {
+      bedrockOptions["cachePoint"] = { type: config.cachePoint.type };
+    }
+    return { bedrock: bedrockOptions };
+  }
+  getReasoningOptions(budget) {
+    if (budget === "none" || budget === 0) {
+      return void 0;
+    }
+    const budgetTokens = this.budgetToTokens(budget);
+    return {
+      bedrock: {
+        reasoning: {
+          budgetTokens
+        }
+      }
+    };
+  }
+  budgetToTokens(budget) {
+    if (typeof budget === "number") return budget;
+    const map = {
+      minimal: 1024,
+      low: 2048,
+      medium: 5e3,
+      high: 1e4
+    };
+    return map[budget] ?? 5e3;
+  }
+  normalizeError(error) {
+    return normalizeBedrockError(error);
+  }
+  isRetryable(error) {
+    return isBedrockRetryable(error);
+  }
+};
+function normalizeDeepSeekError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isDeepSeekRetryable(error),
+      provider: "deepseek",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isDeepSeekRetryable(error),
+      provider: "deepseek",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "deepseek",
+    originalError: error
+  };
+}
+function isDeepSeekRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/deepseek/src/adapter.ts
+var DeepseekProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createDeepSeek({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      headers: config.headers,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "deepseek";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  normalizeError(error) {
+    return normalizeDeepSeekError(error);
+  }
+  isRetryable(error) {
+    return isDeepSeekRetryable(error);
+  }
+};
+function normalizeGoogleError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isGoogleRetryable(error),
+      provider: "google",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isGoogleRetryable(error),
+      provider: "google",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "google",
+    originalError: error
+  };
+}
+function isGoogleRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("quota exceeded")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/google/src/tools.ts
+function buildGoogleTools(client, toolNames, options) {
+  const tools = {};
+  for (const name of toolNames) {
+    switch (name) {
+      case "googleSearch": {
+        const googleSearchTool = client.tools.googleSearch({});
+        tools["google_search"] = googleSearchTool;
+        break;
+      }
+      case "codeExecution": {
+        const codeExecutionTool = client.tools.codeExecution({});
+        tools["code_execution"] = codeExecutionTool;
+        break;
+      }
+      case "urlContext": {
+        const urlContextTool = client.tools.urlContext({});
+        tools["url_context"] = urlContextTool;
+        break;
+      }
+      case "fileSearch": {
+        const storeNames = options?.fileSearch?.vectorStoreIds;
+        if (!storeNames || storeNames.length === 0) {
+          console.warn(
+            "Google fileSearch tool requires fileSearchStoreNames. Set providerToolOptions.fileSearch.vectorStoreIds to use this tool."
+          );
+          break;
+        }
+        const fileSearchTool = client.tools.fileSearch({
+          fileSearchStoreNames: storeNames,
+          topK: options?.fileSearch?.maxNumResults
+        });
+        tools["file_search"] = fileSearchTool;
+        break;
+      }
+      case "googleMaps": {
+        const googleMapsTool = client.tools.googleMaps(options?.googleMaps?.retrievalConfig ?? {});
+        tools["google_maps"] = googleMapsTool;
+        break;
+      }
+    }
+  }
+  return tools;
+}
+
+// ../../packages/providers/google/src/adapter.ts
+var GoogleProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createGoogleGenerativeAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      headers: config.headers,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "google";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderTools(toolNames, options) {
+    return buildGoogleTools(this.client, toolNames, options);
+  }
+  normalizeError(error) {
+    return normalizeGoogleError(error);
+  }
+  isRetryable(error) {
+    return isGoogleRetryable(error);
+  }
+  getReasoningOptions(budget) {
+    const budgetTokens = this.budgetToTokens(budget);
+    return {
+      google: {
+        thinkingConfig: {
+          thinkingBudget: budgetTokens,
+          includeThoughts: true
+        }
+      }
+    };
+  }
+  budgetToTokens(budget) {
+    if (typeof budget === "number") return budget;
+    const map = {
+      minimal: 1024,
+      low: 2048,
+      medium: 5e3,
+      high: 1e4
+    };
+    return map[budget] ?? 5e3;
+  }
+};
+function normalizeOllamaError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isOllamaRetryable(error),
+      provider: "ollama",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isOllamaRetryable(error),
+      provider: "ollama",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "ollama",
+    originalError: error
+  };
+}
+function isOllamaRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+    if (message.includes("connection refused")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/ollama/src/adapter.ts
+var OllamaProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createOllama({
+      baseURL: config.baseUrl,
+      headers: config.headers,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "ollama";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderOptions(config) {
+    if (config?.think === void 0) {
+      return void 0;
+    }
+    return {
+      ollama: {
+        think: config.think
+      }
+    };
+  }
+  getReasoningOptions(budget) {
+    if (budget === "none" || budget === 0) {
+      return void 0;
+    }
+    return {
+      ollama: {
+        think: true
+      }
+    };
+  }
+  normalizeError(error) {
+    return normalizeOllamaError(error);
+  }
+  isRetryable(error) {
+    return isOllamaRetryable(error);
+  }
+};
+function normalizeOpenAIError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isOpenAIRetryable(error),
+      provider: "openai",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isOpenAIRetryable(error),
+      provider: "openai",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "openai",
+    originalError: error
+  };
+}
+function isOpenAIRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/openai/src/tools.ts
+function buildOpenAITools(client, toolNames, options) {
+  const tools = {};
+  for (const name of toolNames) {
+    switch (name) {
+      case "webSearch": {
+        const webSearchTool = client.tools.webSearch();
+        tools["web_search"] = webSearchTool;
+        break;
+      }
+      case "fileSearch": {
+        const vectorStoreIds = options?.fileSearch?.vectorStoreIds;
+        if (!vectorStoreIds || vectorStoreIds.length === 0) {
+          console.warn(
+            "OpenAI fileSearch tool requires vectorStoreIds. Set providerToolOptions.fileSearch.vectorStoreIds to use this tool."
+          );
+          break;
+        }
+        const fileSearchTool = client.tools.fileSearch({
+          vectorStoreIds,
+          maxNumResults: options?.fileSearch?.maxNumResults
+        });
+        tools["file_search"] = fileSearchTool;
+        break;
+      }
+      case "codeInterpreter": {
+        const codeInterpreterTool = client.tools.codeInterpreter();
+        tools["code_interpreter"] = codeInterpreterTool;
+        break;
+      }
+      case "imageGeneration": {
+        const imageGenerationTool = client.tools.imageGeneration();
+        tools["image_generation"] = imageGenerationTool;
+        break;
+      }
+    }
+  }
+  return tools;
+}
+
+// ../../packages/providers/openai/src/adapter.ts
+var OpenAIProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createOpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      organization: config.organization,
+      project: config.project,
+      name: config.name,
+      headers: config.headers,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "openai";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderTools(toolNames, options) {
+    return buildOpenAITools(this.client, toolNames, options);
+  }
+  getReasoningOptions(budget) {
+    const effort = this.budgetToEffort(budget);
+    return {
+      openai: { reasoningEffort: effort }
+    };
+  }
+  budgetToEffort(budget) {
+    if (typeof budget === "number") {
+      if (budget <= 2048) return "low";
+      if (budget <= 5e3) return "medium";
+      return "high";
+    }
+    if (budget === "minimal") return "low";
+    return budget;
+  }
+  normalizeError(error) {
+    return normalizeOpenAIError(error);
+  }
+  isRetryable(error) {
+    return isOpenAIRetryable(error);
+  }
+};
+function normalizeVertexError(error) {
+  if (error instanceof APICallError) {
+    return {
+      name: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+      isRetryable: isVertexRetryable(error),
+      provider: "google-vertex",
+      originalError: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      isRetryable: isVertexRetryable(error),
+      provider: "google-vertex",
+      originalError: error
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    isRetryable: false,
+    provider: "google-vertex",
+    originalError: error
+  };
+}
+function isVertexRetryable(error) {
+  if (error instanceof APICallError) {
+    if (error.isRetryable) return true;
+    const statusCode = error.statusCode;
+    if (statusCode === 429) return true;
+    if (statusCode === 500) return true;
+    if (statusCode === 502) return true;
+    if (statusCode === 503) return true;
+    if (statusCode === 504) return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit")) return true;
+    if (message.includes("quota exceeded")) return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("service unavailable")) return true;
+  }
+  return false;
+}
+
+// ../../packages/providers/vertex/src/tools.ts
+function buildVertexTools(client, toolNames, options) {
+  const tools = {};
+  for (const name of toolNames) {
+    switch (name) {
+      case "googleSearch": {
+        const googleSearchTool = client.tools.googleSearch({});
+        tools["google_search"] = googleSearchTool;
+        break;
+      }
+      case "codeExecution": {
+        const codeExecutionTool = client.tools.codeExecution({});
+        tools["code_execution"] = codeExecutionTool;
+        break;
+      }
+      case "urlContext": {
+        const urlContextTool = client.tools.urlContext({});
+        tools["url_context"] = urlContextTool;
+        break;
+      }
+      case "enterpriseWebSearch": {
+        const enterpriseWebSearchTool = client.tools.enterpriseWebSearch({});
+        tools["enterprise_web_search"] = enterpriseWebSearchTool;
+        break;
+      }
+      case "googleMaps": {
+        const googleMapsTool = client.tools.googleMaps(options?.googleMaps?.retrievalConfig ?? {});
+        tools["google_maps"] = googleMapsTool;
+        break;
+      }
+    }
+  }
+  return tools;
+}
+
+// ../../packages/providers/vertex/src/adapter.ts
+var VertexProviderAdapter = class extends BaseProviderAdapter {
+  constructor(config, options) {
+    super(options);
+    this.config = config;
+    this.client = createVertex({
+      project: config.project,
+      location: config.location,
+      baseURL: config.baseUrl,
+      headers: config.headers,
+      fetch: options?.proxyUrl ? this.createProxyFetch(options.proxyUrl) : void 0
+    });
+  }
+  providerName = "google-vertex";
+  client;
+  createModel(modelId) {
+    return this.client(modelId);
+  }
+  getProviderTools(toolNames, options) {
+    return buildVertexTools(this.client, toolNames, options);
+  }
+  getProviderOptions(config) {
+    if (!config?.safetySettings || config.safetySettings.length === 0) {
+      return void 0;
+    }
+    return {
+      vertex: {
+        safetySettings: config.safetySettings
+      }
+    };
+  }
+  getReasoningOptions(budget) {
+    if (budget === "none" || budget === 0) {
+      return void 0;
+    }
+    const budgetTokens = this.budgetToTokens(budget);
+    return {
+      vertex: {
+        thinkingConfig: {
+          thinkingBudget: budgetTokens,
+          includeThoughts: true
+        }
+      }
+    };
+  }
+  budgetToTokens(budget) {
+    if (typeof budget === "number") return budget;
+    const map = {
+      minimal: 1024,
+      low: 2048,
+      medium: 5e3,
+      high: 1e4
+    };
+    return map[budget] ?? 5e3;
+  }
+  normalizeError(error) {
+    return normalizeVertexError(error);
+  }
+  isRetryable(error) {
+    return isVertexRetryable(error);
+  }
+};
 
 // src/helpers/register-providers.ts
-registerProviderAdapter("anthropic", async () => {
-  const { AnthropicProviderAdapter } = await import('@perstack/anthropic-provider');
-  return AnthropicProviderAdapter;
-});
-registerProviderAdapter("openai", async () => {
-  const { OpenAIProviderAdapter } = await import('@perstack/openai-provider');
-  return OpenAIProviderAdapter;
-});
-registerProviderAdapter("google", async () => {
-  const { GoogleProviderAdapter } = await import('@perstack/google-provider');
-  return GoogleProviderAdapter;
-});
-registerProviderAdapter("ollama", async () => {
-  const { OllamaProviderAdapter } = await import('@perstack/ollama-provider');
-  return OllamaProviderAdapter;
-});
-registerProviderAdapter("azure-openai", async () => {
-  const { AzureOpenAIProviderAdapter } = await import('@perstack/azure-openai-provider');
-  return AzureOpenAIProviderAdapter;
-});
-registerProviderAdapter("amazon-bedrock", async () => {
-  const { BedrockProviderAdapter } = await import('@perstack/bedrock-provider');
-  return BedrockProviderAdapter;
-});
-registerProviderAdapter("google-vertex", async () => {
-  const { VertexProviderAdapter } = await import('@perstack/vertex-provider');
-  return VertexProviderAdapter;
-});
-registerProviderAdapter("deepseek", async () => {
-  const { DeepseekProviderAdapter } = await import('@perstack/deepseek-provider');
-  return DeepseekProviderAdapter;
-});
+registerProviderAdapter(
+  "anthropic",
+  async () => AnthropicProviderAdapter
+);
+registerProviderAdapter(
+  "openai",
+  async () => OpenAIProviderAdapter
+);
+registerProviderAdapter(
+  "google",
+  async () => GoogleProviderAdapter
+);
+registerProviderAdapter(
+  "ollama",
+  async () => OllamaProviderAdapter
+);
+registerProviderAdapter(
+  "azure-openai",
+  async () => AzureOpenAIProviderAdapter
+);
+registerProviderAdapter(
+  "amazon-bedrock",
+  async () => BedrockProviderAdapter
+);
+registerProviderAdapter(
+  "google-vertex",
+  async () => VertexProviderAdapter
+);
+registerProviderAdapter(
+  "deepseek",
+  async () => DeepseekProviderAdapter
+);
 var shouldEnableReasoning = (budget) => budget !== void 0 && budget !== "none" && budget !== 0;
 var LLMExecutor = class {
   constructor(adapter, model) {
@@ -2636,5 +3656,5 @@ async function run(runInput, options) {
 }
 
 export { findLockfile, getLockfileExpertToolDefinitions, getModel, loadLockfile, package_default, run, runtimeStateMachine };
-//# sourceMappingURL=chunk-LDJKVMQK.js.map
-//# sourceMappingURL=chunk-LDJKVMQK.js.map
+//# sourceMappingURL=chunk-BXJGGA3Q.js.map
+//# sourceMappingURL=chunk-BXJGGA3Q.js.map