@organizaone/o1-code 0.11.3 → 0.13.0

package/chunks/{chunk-H2U6QRJX.js → chunk-72EBG4FJ.js}

@@ -1,8 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  preloadRuntimeFetchModule
-} from "./chunk-HDGYCLNB.js";
 import {
   init_esbuild_shims
 } from "./chunk-S2467S6L.js";
@@ -10,204 +7,6 @@ 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/tokenLimits.ts
 init_esbuild_shims();
 var DEFAULT_TOKEN_LIMIT = 2e5;
@@ -652,248 +451,6 @@ function parseModelReasoningCapabilities(value) {
 }
 __name(parseModelReasoningCapabilities, "parseModelReasoningCapabilities");
 
-// 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-62C5JSNE.js");
-        return createOpenAIContentGenerator(generatorConfig, config);
-      }, "loadBaseGenerator");
-    } else if (authType === "openai-responses" /* USE_OPENAI_RESPONSES */) {
-      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-JSS3U575.js");
-        return createOpenAIResponsesContentGenerator(generatorConfig, config);
-      }, "loadBaseGenerator");
-    } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-2VK5J36U.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-I62R6Q4I.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-53CAIYCN.js")
-      ]);
-      return new LoggingContentGenerator(
-        baseGenerator,
-        config,
-        generatorConfig
-      );
-    } catch (error) {
-      throw wrapProviderLoadError(error, authType);
-    }
-  });
-}
-__name(createContentGenerator, "createContentGenerator");
-
 // packages/core/src/core/modalityDefaults.ts
 init_esbuild_shims();
 var FULL_MULTIMODAL = {
@@ -1009,15 +566,6 @@ function isTieredEffortWireModel(model, configuredReasoning) {
 __name(isTieredEffortWireModel, "isTieredEffortWireModel");
 
 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,
   DEFAULT_TOKEN_LIMIT,
   OUTPUT_TOKEN_CEILING,
   clampOutputTokensToWindow,
@@ -1040,31 +588,15 @@ export {
   parseModelReasoningCapabilities,
   defaultModalities,
   isDashScopeWireModel,
-  isTieredEffortWireModel,
-  resolveContentGeneratorConfigWithSources,
-  hasVertexProjectConfigured,
-  preloadContentGenerator,
-  resetPreloadedContentGenerator,
-  createContentGenerator
+  isTieredEffortWireModel
 };
 /**
  * @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
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-4OI2JVHJ.js → chunk-776VI66O.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   getRateLimitErrorDetails
-} from "./chunk-7USF7X6U.js";
+} from "./chunk-TC2TJAOF.js";
 import {
   isInternalPromptId
-} from "./chunk-BSLKB37V.js";
+} from "./chunk-ZGPPP7FC.js";
 import {
   createDebugLogger
 } from "./chunk-UK2KIU2V.js";

package/chunks/{chunk-COABCWBY.js → chunk-7S2AYA27.js}

@@ -639,6 +639,20 @@ function buildSystemPromptSuffix(text) {
 ${trimmed}` : "";
 }
 __name(buildSystemPromptSuffix, "buildSystemPromptSuffix");
+var SUMMARY_MODE_PROMPT = `# Display mode: Summary
+
+The user chose the Summary display mode: they follow your work through short sentences and do not read code.
+
+- Write in plain language. Say what you are doing and why, not how.
+- Do not include code blocks, diffs, file contents or full commands unless the user asks for them. Name a file only when it helps the user.
+- Always state the risks, caveats and failed checks, and anything the user must decide or do. Summary never means leaving those out.`;
+function withDisplayModePrompt(prompt, displayMode, interactionMode) {
+  if (displayMode !== "summary" || interactionMode !== "interactive") {
+    return prompt;
+  }
+  return `${prompt}${buildSystemPromptSuffix(SUMMARY_MODE_PROMPT)}`;
+}
+__name(withDisplayModePrompt, "withDisplayModePrompt");
 function assembleSystemPrompt(layers) {
   return layers.base + buildSystemPromptSuffix(layers.mediaGuidance ?? void 0) + buildSystemPromptSuffix(layers.contextFiles) + buildSystemPromptSuffix(layers.appendPrompt) + (layers.gitStatus ? `
 
@@ -1910,6 +1924,7 @@ export {
   getCustomSystemPrompt,
   resolveMainSessionOutputStyle,
   getCoreSystemPrompt,
+  withDisplayModePrompt,
   assembleSystemPrompt,
   getCompressionPrompt,
   getProjectSummaryPrompt,

package/chunks/chunk-7TK6OY2J.js

@@ -0,0 +1,53 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/mcp/token-storage/base-token-storage.ts
+init_esbuild_shims();
+var BaseTokenStorage = class {
+  static {
+    __name(this, "BaseTokenStorage");
+  }
+  serviceName;
+  constructor(serviceName) {
+    this.serviceName = serviceName;
+  }
+  validateCredentials(credentials) {
+    if (!credentials.serverName) {
+      throw new Error("Server name is required");
+    }
+    if (!credentials.token) {
+      throw new Error("Token is required");
+    }
+    if (!credentials.token.accessToken) {
+      throw new Error("Access token is required");
+    }
+    if (!credentials.token.tokenType) {
+      throw new Error("Token type is required");
+    }
+  }
+  isTokenExpired(credentials) {
+    if (!credentials.token.expiresAt) {
+      return false;
+    }
+    const bufferMs = 5 * 60 * 1e3;
+    return Date.now() + bufferMs >= credentials.token.expiresAt;
+  }
+  sanitizeServerName(serverName) {
+    return serverName.replace(/[^a-zA-Z0-9-_.]/g, "_");
+  }
+};
+
+export {
+  BaseTokenStorage
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */