@organizaone/o1-code 0.11.3 → 0.13.0

package/chunks/chunk-6Z3USRSR.js

@@ -0,0 +1,484 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  preloadRuntimeFetchModule
+} from "./chunk-HDGYCLNB.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/models/modelConfigErrors.ts
+init_esbuild_shims();
+function getDefaultApiKeyEnvVar(authType) {
+  switch (authType) {
+    case "openai":
+    case "openai-responses":
+      return "OPENAI_API_KEY";
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "gemini":
+      return "GEMINI_API_KEY";
+    case "vertex-ai":
+      return "GOOGLE_API_KEY";
+    default:
+      return "API_KEY";
+  }
+}
+__name(getDefaultApiKeyEnvVar, "getDefaultApiKeyEnvVar");
+function getDefaultModelEnvVar(authType) {
+  switch (authType) {
+    case "openai":
+    case "openai-responses":
+      return "OPENAI_MODEL";
+    case "anthropic":
+      return "ANTHROPIC_MODEL";
+    case "gemini":
+      return "GEMINI_MODEL";
+    case "vertex-ai":
+      return "GOOGLE_MODEL";
+    default:
+      return "MODEL";
+  }
+}
+__name(getDefaultModelEnvVar, "getDefaultModelEnvVar");
+var VERTEX_ADC_HINT = " Alternatively, set GOOGLE_CLOUD_PROJECT to authenticate with Application Default Credentials instead of an API key.";
+function adcHint(authType, explicitEnvKey) {
+  return authType === "vertex-ai" && !explicitEnvKey ? VERTEX_ADC_HINT : "";
+}
+__name(adcHint, "adcHint");
+var ModelConfigError = class extends Error {
+  static {
+    __name(this, "ModelConfigError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var StrictMissingCredentialsError = class extends ModelConfigError {
+  static {
+    __name(this, "StrictMissingCredentialsError");
+  }
+  code = "STRICT_MISSING_CREDENTIALS";
+  constructor(authType, model, envKey) {
+    const providerKey = authType || "(unknown)";
+    const modelName = model || "(unknown)";
+    super(
+      `Missing credentials for modelProviders model '${modelName}'. ` + (envKey ? `Current configured envKey: '${envKey}'. Set that environment variable, or update modelProviders.${providerKey}[].envKey.` : `Configure modelProviders.${providerKey}[].envKey and set that environment variable.`) + adcHint(authType, envKey)
+    );
+  }
+};
+var StrictMissingModelIdError = class extends ModelConfigError {
+  static {
+    __name(this, "StrictMissingModelIdError");
+  }
+  code = "STRICT_MISSING_MODEL_ID";
+  constructor(authType) {
+    super(
+      `Missing model id for strict modelProviders resolution (authType: ${authType}).`
+    );
+  }
+};
+var MissingApiKeyError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingApiKeyError");
+  }
+  code = "MISSING_API_KEY";
+  constructor(params) {
+    super(
+      `Missing API key for ${params.authType} auth. Current model: '${params.model || "(unknown)"}', baseUrl: '${params.baseUrl || "(default)"}'. Connect a provider with /auth, or set the environment variable '${params.envKey}'.` + adcHint(params.authType, params.explicitEnvKey)
+    );
+  }
+};
+var MissingModelError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingModelError");
+  }
+  code = "MISSING_MODEL";
+  constructor(params) {
+    super(
+      `Missing model for ${params.authType} auth. Set the environment variable '${params.envKey}'.`
+    );
+  }
+};
+var MissingBaseUrlError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingBaseUrlError");
+  }
+  code = "MISSING_BASE_URL";
+  constructor(params) {
+    super(
+      `Missing baseUrl for modelProviders model '${params.model || "(unknown)"}'. Configure modelProviders.${params.authType || "(unknown)"}[].baseUrl.`
+    );
+  }
+};
+var MissingAnthropicBaseUrlEnvError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingAnthropicBaseUrlEnvError");
+  }
+  code = "MISSING_ANTHROPIC_BASE_URL_ENV";
+  constructor() {
+    super("ANTHROPIC_BASE_URL environment variable not found.");
+  }
+};
+
+// packages/core/src/config/models.ts
+init_esbuild_shims();
+var DEFAULT_O1CODE_EMBEDDING_MODEL = "text-embedding-v4";
+var MAINLINE_CODER_MODEL = "qwen3.7-max";
+
+// packages/core/src/models/constants.ts
+init_esbuild_shims();
+var MODEL_GENERATION_CONFIG_FIELDS = [
+  "samplingParams",
+  "timeout",
+  "streamIdleTimeoutMs",
+  "maxRetries",
+  "retryInitialDelayMs",
+  "retryMaxDelayMs",
+  "retryErrorCodes",
+  "enableCacheControl",
+  "enableRequestMetadata",
+  "forceGlobalCacheScope",
+  "cacheRetention",
+  "cacheRetentionByBlock",
+  "schemaCompliance",
+  "reasoning",
+  "contextWindowSize",
+  "customHeaders",
+  "extra_body",
+  "thinkingMandatory",
+  "modalities",
+  "splitToolMedia",
+  "toolResultContentFormat"
+];
+var CREDENTIAL_FIELDS = [
+  "model",
+  "apiKey",
+  "apiKeyEnvKey",
+  "baseUrl"
+];
+var PROVIDER_SOURCED_FIELDS = [
+  ...CREDENTIAL_FIELDS,
+  ...MODEL_GENERATION_CONFIG_FIELDS
+];
+var AUTH_ENV_MAPPINGS = {
+  openai: {
+    apiKey: ["OPENAI_API_KEY"],
+    baseUrl: ["OPENAI_BASE_URL"],
+    model: ["OPENAI_MODEL", "O1CODE_MODEL"]
+  },
+  "openai-responses": {
+    apiKey: ["OPENAI_API_KEY"],
+    baseUrl: ["OPENAI_BASE_URL"],
+    model: ["OPENAI_MODEL"]
+  },
+  anthropic: {
+    apiKey: ["ANTHROPIC_API_KEY"],
+    baseUrl: ["ANTHROPIC_BASE_URL"],
+    model: ["ANTHROPIC_MODEL"]
+  },
+  gemini: {
+    apiKey: ["GEMINI_API_KEY"],
+    baseUrl: [],
+    model: ["GEMINI_MODEL"]
+  },
+  "vertex-ai": {
+    apiKey: ["GOOGLE_API_KEY"],
+    baseUrl: [],
+    model: ["GOOGLE_MODEL"]
+  }
+};
+var DEFAULT_MODELS = {
+  openai: MAINLINE_CODER_MODEL
+};
+
+// packages/core/src/utils/auth-type.ts
+init_esbuild_shims();
+var AuthType = /* @__PURE__ */ ((AuthType2) => {
+  AuthType2["USE_OPENAI"] = "openai";
+  AuthType2["USE_OPENAI_RESPONSES"] = "openai-responses";
+  AuthType2["USE_GEMINI"] = "gemini";
+  AuthType2["USE_VERTEX_AI"] = "vertex-ai";
+  AuthType2["USE_ANTHROPIC"] = "anthropic";
+  return AuthType2;
+})(AuthType || {});
+
+// packages/core/src/core/contentGenerator.ts
+init_esbuild_shims();
+function setSource(sources, path, source) {
+  sources[path] = source;
+}
+__name(setSource, "setSource");
+function getSeedSource(seed, path) {
+  return seed?.[path];
+}
+__name(getSeedSource, "getSeedSource");
+function resolveContentGeneratorConfigWithSources(config, authType, generationConfig, seedSources, options) {
+  const sources = { ...seedSources || {} };
+  const strictModelProvider = options?.strictModelProvider === true;
+  const newContentGeneratorConfig = {
+    ...generationConfig || {},
+    authType,
+    reasoningSnapshot: generationConfig?.reasoningSnapshot ?? config?.getReasoningSnapshot?.(),
+    reasoningRouteBaseUrl: generationConfig && "reasoningRouteBaseUrl" in generationConfig ? generationConfig.reasoningRouteBaseUrl : config?.getCurrentModelRegistryBaseUrl?.(),
+    proxy: config?.getProxy()
+  };
+  setSource(sources, "authType", {
+    kind: "computed",
+    detail: "provided by caller"
+  });
+  if (config?.getProxy()) {
+    setSource(sources, "proxy", {
+      kind: "computed",
+      detail: "Config.getProxy()"
+    });
+  }
+  const seedOrUnknown = /* @__PURE__ */ __name((path) => getSeedSource(seedSources, path) ?? { kind: "unknown" }, "seedOrUnknown");
+  for (const field of PROVIDER_SOURCED_FIELDS) {
+    if (generationConfig && field in generationConfig && !sources[field]) {
+      setSource(sources, field, seedOrUnknown(field));
+    }
+  }
+  const validation = validateModelConfig(
+    newContentGeneratorConfig,
+    strictModelProvider
+  );
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((e) => e.message).join("\n"));
+  }
+  return {
+    config: newContentGeneratorConfig,
+    sources
+  };
+}
+__name(resolveContentGeneratorConfigWithSources, "resolveContentGeneratorConfigWithSources");
+var VERTEX_PROJECT_ENV_VAR = "GOOGLE_CLOUD_PROJECT";
+function hasVertexProjectConfigured(lookup = (key) => process.env[key]) {
+  return !!lookup(VERTEX_PROJECT_ENV_VAR)?.trim();
+}
+__name(hasVertexProjectConfigured, "hasVertexProjectConfigured");
+function usesVertexApplicationDefaultCredentials(config) {
+  return config.authType === "vertex-ai" /* USE_VERTEX_AI */ && !config.apiKeyEnvKey && hasVertexProjectConfigured();
+}
+__name(usesVertexApplicationDefaultCredentials, "usesVertexApplicationDefaultCredentials");
+function validateModelConfig(config, isStrictModelProvider = false) {
+  const errors = [];
+  if (!config.apiKey && !usesVertexApplicationDefaultCredentials(config)) {
+    if (isStrictModelProvider) {
+      errors.push(
+        new StrictMissingCredentialsError(
+          config.authType,
+          config.model,
+          config.apiKeyEnvKey
+        )
+      );
+    } else {
+      const envKey = config.apiKeyEnvKey || getDefaultApiKeyEnvVar(config.authType);
+      errors.push(
+        new MissingApiKeyError({
+          authType: config.authType,
+          model: config.model,
+          baseUrl: config.baseUrl,
+          envKey,
+          explicitEnvKey: config.apiKeyEnvKey
+        })
+      );
+    }
+  }
+  if (!config.model) {
+    if (isStrictModelProvider) {
+      errors.push(new StrictMissingModelIdError(config.authType));
+    } else {
+      const envKey = getDefaultModelEnvVar(config.authType);
+      errors.push(new MissingModelError({ authType: config.authType, envKey }));
+    }
+  }
+  if (config.authType === "anthropic" /* USE_ANTHROPIC */ && !config.baseUrl) {
+    if (isStrictModelProvider) {
+      errors.push(
+        new MissingBaseUrlError({
+          authType: config.authType,
+          model: config.model
+        })
+      );
+    } else if (config.authType === "anthropic" /* USE_ANTHROPIC */) {
+      errors.push(new MissingAnthropicBaseUrlEnvError());
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+__name(validateModelConfig, "validateModelConfig");
+function getModuleNotFoundError(error) {
+  let current = error;
+  while (current instanceof Error) {
+    if ("code" in current && current.code === "ERR_MODULE_NOT_FOUND") {
+      return current;
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
+__name(getModuleNotFoundError, "getModuleNotFoundError");
+function wrapProviderLoadError(error, authType) {
+  const moduleNotFoundError = getModuleNotFoundError(error);
+  if (!moduleNotFoundError) {
+    return error;
+  }
+  return new Error(
+    `O1-Code was updated in the background and needs to be restarted.
+Please exit and restart O1-Code to use the '${authType}' provider.`,
+    { cause: moduleNotFoundError }
+  );
+}
+__name(wrapProviderLoadError, "wrapProviderLoadError");
+var LazyContentGenerator = class {
+  constructor(loader) {
+    this.loader = loader;
+  }
+  static {
+    __name(this, "LazyContentGenerator");
+  }
+  generatorPromise;
+  preloadedOnly = false;
+  getGenerator() {
+    this.generatorPromise ??= this.loader();
+    return this.generatorPromise;
+  }
+  getGeneratorForUse() {
+    this.preloadedOnly = false;
+    return this.getGenerator();
+  }
+  preload() {
+    if (!this.generatorPromise) {
+      this.preloadedOnly = true;
+    }
+    return this.getGenerator();
+  }
+  resetPreload() {
+    if (!this.preloadedOnly) return;
+    this.preloadedOnly = false;
+    this.generatorPromise = void 0;
+  }
+  async generateContent(request, userPromptId) {
+    return (await this.getGeneratorForUse()).generateContent(
+      request,
+      userPromptId
+    );
+  }
+  async generateContentStream(request, userPromptId) {
+    return (await this.getGeneratorForUse()).generateContentStream(
+      request,
+      userPromptId
+    );
+  }
+  async embedContent(request) {
+    return (await this.getGeneratorForUse()).embedContent(request);
+  }
+};
+async function preloadContentGenerator(generator) {
+  if (generator instanceof LazyContentGenerator) {
+    await generator.preload();
+  }
+}
+__name(preloadContentGenerator, "preloadContentGenerator");
+function resetPreloadedContentGenerator(generator) {
+  if (generator instanceof LazyContentGenerator) {
+    generator.resetPreload();
+  }
+}
+__name(resetPreloadedContentGenerator, "resetPreloadedContentGenerator");
+async function createContentGenerator(generatorConfig, config) {
+  const validation = validateModelConfig(generatorConfig, false);
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((e) => e.message).join("\n"));
+  }
+  const authType = generatorConfig.authType;
+  if (!authType) {
+    throw new Error("ContentGeneratorConfig must have an authType");
+  }
+  await preloadRuntimeFetchModule();
+  let loadBaseGenerator;
+  try {
+    if (authType === "openai" /* USE_OPENAI */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-54R7P33Y.js");
+        return createOpenAIContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "openai-responses" /* USE_OPENAI_RESPONSES */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-5TBBBXGD.js");
+        return createOpenAIResponsesContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-4K7EQGUO.js");
+        return createAnthropicContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createLlmContentGenerator } = await import("./llm-content-generator-7L62PNT2.js");
+        return createLlmContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else {
+      throw new Error(
+        `Error creating contentGenerator: Unsupported authType: ${authType}`
+      );
+    }
+  } catch (error) {
+    throw wrapProviderLoadError(error, authType);
+  }
+  return new LazyContentGenerator(async () => {
+    try {
+      const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
+        loadBaseGenerator(),
+        import("./loggingContentGenerator-ZY3AEK2S.js")
+      ]);
+      return new LoggingContentGenerator(
+        baseGenerator,
+        config,
+        generatorConfig
+      );
+    } catch (error) {
+      throw wrapProviderLoadError(error, authType);
+    }
+  });
+}
+__name(createContentGenerator, "createContentGenerator");
+
+export {
+  getDefaultApiKeyEnvVar,
+  VERTEX_ADC_HINT,
+  DEFAULT_O1CODE_EMBEDDING_MODEL,
+  MAINLINE_CODER_MODEL,
+  MODEL_GENERATION_CONFIG_FIELDS,
+  PROVIDER_SOURCED_FIELDS,
+  AUTH_ENV_MAPPINGS,
+  DEFAULT_MODELS,
+  AuthType,
+  resolveContentGeneratorConfigWithSources,
+  hasVertexProjectConfigured,
+  preloadContentGenerator,
+  resetPreloadedContentGenerator,
+  createContentGenerator
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */