dominds 1.28.0 → 1.29.0

package/dist/llm/gen/codex.js

@@ -4,9 +4,11 @@ exports.CodexGen = void 0;
 exports.resolveCodexToolChoice = resolveCodexToolChoice;
 exports.resolveCodexServiceTier = resolveCodexServiceTier;
 exports.resolveCodexInstructions = resolveCodexInstructions;
+exports.resolveCodexReasoningEffortForRequest = resolveCodexReasoningEffortForRequest;
 const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
+const api_quirks_1 = require("../api-quirks");
 const artifacts_1 = require("./artifacts");
 const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
@@ -14,6 +16,24 @@ const tool_output_limit_1 = require("./tool-output-limit");
 const tool_result_image_ingest_1 = require("./tool-result-image-ingest");
 const log = (0, log_1.createLogger)('llm/codex');
 const codexFallbackInstructions = 'You are Codex CLI.';
+// Runtime import of codex-auth is dynamic because Dominds is CommonJS; keep this discriminator
+// identical to the exported codex-auth policy error code.
+const DOMINDS_CODEX_PROVIDER_AUTH_POLICY_ERROR_CODE = 'DOMINDS_CODEX_PROVIDER_AUTH_POLICY';
+const codexAntiEarlyFinalizationInstructionSections = {
+    zh: {
+        title: '每轮作答前的推理完成检查',
+        body: '请在每轮作答前至少花一分钟推理。深入而充分地思考。在给出本轮答案前，证明充分性和必要性。',
+    },
+    en: {
+        title: 'Reasoning Completion Guard',
+        body: 'Please spend at least a minute reasoning before each response. Think long and hard. Prove both sufficiency and necessity before giving the answer for this turn.',
+    },
+};
+function isDomindsCodexProviderAuthPolicyError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === DOMINDS_CODEX_PROVIDER_AUTH_POLICY_ERROR_CODE);
+}
 function resolveCodexToolChoice(tools, requestContext) {
     const requirement = requestContext.toolUseRequirement ?? 'auto';
     if (tools.length === 0) {
@@ -105,8 +125,20 @@ function tryExtractApiReturnedModel(value) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-function resolveCodexInstructions(systemPrompt) {
-    return systemPrompt.trim().length > 0 ? systemPrompt : codexFallbackInstructions;
+function applyCodexInstructionQuirks(instructions, providerConfig) {
+    if (!providerConfig)
+        return instructions;
+    if (providerConfig.apiType !== 'codex')
+        return instructions;
+    const quirks = (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig);
+    if (!quirks.has(api_quirks_1.CODEX_ANTI_EARLY_FINALIZATION_API_QUIRK))
+        return instructions;
+    const section = codexAntiEarlyFinalizationInstructionSections[(0, work_language_1.getWorkLanguage)()];
+    return `${instructions}\n\n## ${section.title}\n${section.body}`;
+}
+function resolveCodexInstructions(systemPrompt, providerConfig) {
+    const instructions = systemPrompt.trim().length > 0 ? systemPrompt : codexFallbackInstructions;
+    return applyCodexInstructionQuirks(instructions, providerConfig);
 }
 function funcToolToCodex(funcTool) {
     // MCP schemas are passed through to providers. Codex tool schema types are narrower; runtime
@@ -162,16 +194,27 @@ function buildCodexTextControls(agent) {
     }
     return Object.keys(text).length > 0 ? text : undefined;
 }
-function buildCodexReasoning(agent) {
+function resolveCodexReasoningEffortForRequest(model, reasoningEffort) {
+    if (model.startsWith('gpt-5.6-') &&
+        (reasoningEffort === 'none' || reasoningEffort === 'minimal')) {
+        throw new Error(`Invalid Codex reasoning_effort=${reasoningEffort} for model '${model}'; GPT-5.6 Codex models support low|medium|high|xhigh|max, plus ultra on Sol and Terra.`);
+    }
+    if (model.startsWith('gpt-5.6-luna') && reasoningEffort === 'ultra') {
+        throw new Error(`Invalid Codex reasoning_effort=ultra for model '${model}'; GPT-5.6 Luna supports up to max.`);
+    }
+    // `ultra` is a Codex client orchestration preset. codex-rs sends `max` to the inference API
+    // and handles the additional delegation behavior locally; never put `ultra` on the wire.
+    return reasoningEffort === 'ultra' ? 'max' : reasoningEffort;
+}
+function buildCodexReasoning(agent, model) {
     // Provider isolation rule: do not borrow OpenAI Responses params inside the Codex wrapper.
     const codexParams = agent.model_params?.codex;
     if (codexParams?.reasoning_effort === undefined && codexParams?.reasoning_summary === undefined) {
         return null;
     }
+    const reasoningEffort = resolveCodexReasoningEffortForRequest(model, codexParams?.reasoning_effort);
     return {
-        ...(codexParams?.reasoning_effort !== undefined
-            ? { effort: codexParams.reasoning_effort }
-            : {}),
+        ...(reasoningEffort !== undefined ? { effort: reasoningEffort } : {}),
         ...(codexParams?.reasoning_summary !== undefined
             ? { summary: codexParams.reasoning_summary }
             : { summary: 'auto' }),
@@ -619,7 +662,7 @@ async function buildCodexRequest(providerConfig, agent, instructions, funcTools,
     // Provider isolation rule: request construction must only read Codex-native params here.
     const codexParams = agent.model_params?.codex;
     const parallelToolCalls = codexParams?.parallel_tool_calls ?? true;
-    const reasoning = buildCodexReasoning(agent);
+    const reasoning = buildCodexReasoning(agent, agent.model);
     const include = reasoning !== null ? ['reasoning.encrypted_content'] : [];
     const serviceTier = resolveCodexServiceTier(codexParams?.service_tier);
     const text = buildCodexTextControls(agent);
@@ -651,6 +694,13 @@ class CodexGen {
         return 'codex';
     }
     classifyFailure(error) {
+        if (isDomindsCodexProviderAuthPolicyError(error)) {
+            return {
+                kind: 'fatal',
+                message: error.message,
+                code: error.code,
+            };
+        }
         return (0, failure_classifier_1.classifyOpenAiLikeFailure)(error);
     }
     async genToReceiver(providerConfig, agent, systemPrompt, funcTools, requestContext, context, receiver, _genseq, abortSignal) {
@@ -661,13 +711,18 @@ class CodexGen {
         // NOTE: `@longrun-ai/codex-auth` is an ESM package (`"type": "module"`). The Dominds backend is
         // compiled as CommonJS, so Node.js requires a dynamic `import()` for runtime access here.
         const codexAuth = await import('@longrun-ai/codex-auth');
+        // PRODUCT POLICY: this provider is intentionally narrower than codex-rs. It accepts only
+        // managed, refreshable ChatGPT OAuth file auth. Keep recognizing new codex-rs auth modes so
+        // they fail with actionable diagnostics, but do not enable them here during future syncs
+        // without an explicit Dominds product decision. Other auth belongs in a custom OpenAI
+        // Responses API provider or a separately approved Dominds feature.
         const authPreparation = codexAuth.prepareCodexFileAuth({
             codexHome,
             codexHomeEnvVar: providerConfig.apiKeyEnvVar,
             providerName: `Dominds codex provider '${providerConfig.name}'`,
         });
         if (authPreparation.kind === 'action_required') {
-            throw new Error(codexAuth.formatCodexFileAuthActionRequired(authPreparation));
+            throw new codexAuth.DomindsCodexProviderAuthPolicyError(codexAuth.formatCodexFileAuthActionRequired(authPreparation));
         }
         if (authPreparation.changedConfigToFile) {
             log.info('Codex CLI auth storage switched to file mode for Dominds codex provider', undefined, {
@@ -676,14 +731,29 @@ class CodexGen {
                 previousStoreMode: authPreparation.previousStoreMode,
             });
         }
-        const manager = new codexAuth.AuthManager({ codexHome });
+        const manager = new codexAuth.AuthManager({
+            codexHome,
+            // Reject ephemeral credentials, incomplete managed auth, or a changed auth.json before
+            // AuthManager can normalize or promote another stored mode into a managed-looking in-memory
+            // state during refresh/401 recovery.
+            validateStoredAuth: codexAuth.assertDomindsCodexProviderManagedChatGptStoredAuth,
+            // Validate environment and external precedence candidates before recovery can compare
+            // account ids or replace the cached state, so policy failures keep their actionable error.
+            validateAuthState: codexAuth.assertDomindsCodexProviderManagedChatGptAuth,
+        });
+        // Defense in depth against AuthManager precedence changes, environment overrides, or
+        // ephemeral credentials appearing after the file-auth preflight and before request creation.
+        codexAuth.assertDomindsCodexProviderManagedChatGptAuth(manager.authCached());
         const client = await codexAuth.createChatGptClientFromManager(manager, {
             baseUrl: providerConfig.baseUrl,
+            // Re-run the product-policy assertion after every auth-manager reload/refresh, before a
+            // recovered request can be sent with credentials that changed during the dialog lifetime.
+            validateAuthState: codexAuth.assertDomindsCodexProviderManagedChatGptAuth,
         });
         if (!agent.model) {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
-        const instructions = resolveCodexInstructions(systemPrompt);
+        const instructions = resolveCodexInstructions(systemPrompt, providerConfig);
         const payload = await buildCodexRequest(providerConfig, agent, instructions, funcTools, requestContext, context, receiver.toolResultImageIngest, receiver.userImageIngest);
         let sayingStarted = false;
         let thinkingStarted = false;
@@ -1006,10 +1076,12 @@ class CodexGen {
                         if (responseUsage &&
                             typeof responseUsage.input_tokens === 'number' &&
                             typeof responseUsage.output_tokens === 'number') {
+                            const reasoningTokens = responseUsage.output_tokens_details?.reasoning_tokens;
                             usage = {
                                 kind: 'available',
                                 promptTokens: responseUsage.input_tokens,
                                 completionTokens: responseUsage.output_tokens,
+                                ...(typeof reasoningTokens === 'number' ? { reasoningTokens } : {}),
                                 totalTokens: typeof responseUsage.total_tokens === 'number'
                                     ? responseUsage.total_tokens
                                     : responseUsage.input_tokens + responseUsage.output_tokens,

package/dist/llm/gen/google.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Module: llm/gen/google
+ *
+ * Google Gemini API integration implementing streaming and batch generation.
+ * Rationale:
+ * - Direct native integration via the official `@google/genai` SDK.
+ * - Supports reasoning/thinking segments via Gemini 2.0+ `thought` parts.
+ * - Supports functional tools/declarations and correlated response structures.
+ */
+import type { Team } from '../../team';
+import type { FuncTool } from '../../tool';
+import { ChatMessage, ProviderConfig } from '../client';
+import { type LlmBatchResult, type LlmFailureDisposition, type LlmGenerator, type LlmRequestContext, type LlmStreamReceiver, type LlmStreamResult } from '../gen';
+export declare class GoogleGen implements LlmGenerator {
+    readonly apiType: string;
+    constructor(apiType?: string);
+    classifyFailure(error: unknown): LlmFailureDisposition | undefined;
+    genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
+    genMoreMessages(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal): Promise<LlmBatchResult>;
+}