@duckcodeailabs/dql-cli 1.6.29 → 1.6.31

package/dist/local-runtime.js

@@ -13,11 +13,13 @@ import { listBlockTemplates } from './block-templates.js';
 import { getRunner as getLLMRunner } from './llm/index.js';
 import { createDqlAgentProviderRunner } from './llm/providers/dql-agent-provider.js';
 import { listRemoteMcpSettings, saveRemoteMcpSettings } from './llm/mcp-config.js';
-import { ClaudeProvider, GeminiProvider, MemoryStore, OllamaProvider, OpenAIProvider, buildBlockBusinessFingerprint, buildBlockSqlFingerprints, buildLocalContextPack, defaultMemoryPath, ensureDefaultMemoryFiles, ensureMetadataCatalogFresh, propose, proposePlan, recordCorrectionTrace, reviewHint, AgentRunEngine, FileAgentRunStore, defaultAgentRunGates, createLlmAgentRunPlanner, createHybridRouter, synthesizeAnswer, streamOrGenerate, narrateResult, normalizeAnthropicBaseUrl, buildProposePreview, buildFromPrompt, defaultAgentRunStorePath, resolveLocalOwner, resolveProposeConfig, recordQueryRun, recordRuntimeSchemaSnapshot, loadSkills, writeSkill, deleteSkill, reindexProject, defaultKgPath, planApp, planResearch, loadSemanticMetrics, } from '@duckcodeailabs/dql-agent';
+import { ClaudeProvider, GeminiProvider, MemoryStore, OllamaProvider, OpenAIProvider, buildBlockBusinessFingerprint, buildBlockSqlFingerprints, buildLocalContextPack, defaultMemoryPath, ensureDefaultMemoryFiles, ensureMetadataCatalogFresh, propose, proposePlan, recordCorrectionTrace, reviewHint, AgentRunEngine, FileAgentRunStore, defaultAgentRunGates, createLlmAgentRunPlanner, createHybridRouter, synthesizeAnswer, streamOrGenerate, narrateResult, normalizeAnthropicBaseUrl, buildProposePreview, buildFromPrompt, defaultAgentRunStorePath, resolveLocalOwner, resolveProposeConfig, recordQueryRun, recordRuntimeSchemaSnapshot, loadSkills, writeSkill, deleteSkill, reindexProject, defaultKgPath, planApp, planResearch, loadSemanticMetrics, routeReasoningEffort, clampReasoningEffort, bumpReasoningEffort, } from '@duckcodeailabs/dql-agent';
 import { gatherProposeEnrichment } from './propose-enrich.js';
 import { handleAppsApi, proposeAppAiBuild, recommendVisualization } from './apps-api.js';
 import { getActiveProvider, getEffectiveProviderConfig, listProviderSettings, saveProviderSettings, } from './settings/provider-settings.js';
 import { ClaudeCodeCliProvider, CodexCliProvider } from './providers/subscription-cli.js';
+import { ClaudeOAuthManager, claudeOAuthConnected, CLAUDE_OAUTH_MODELS, CLAUDE_OAUTH_DEFAULT_MODEL, } from './providers/oauth/claude-oauth.js';
+import { CodexOAuthManager, codexOAuthConnected, CODEX_OAUTH_MODELS, CODEX_OAUTH_DEFAULT_MODEL, } from './providers/oauth/codex-oauth.js';
 import { DQLAccessDeniedError, activePersonaAppId, assertAppAccess, loadRuntimeApp, runtimeVariables, } from './governance-runtime.js';
 import { LocalAppStorage, LocalNotebookResearchStorage, defaultLocalAppsDbPath, defaultNotebookResearchDbPath } from '@duckcodeailabs/dql-project';
 import { Certifier, ENTERPRISE_RULES, evaluateInvariants, hasInvariantViolation, } from '@duckcodeailabs/dql-governance';
@@ -366,7 +368,7 @@ export async function startLocalServer(opts) {
             return provider.generate([{ role: 'system', content: system }, { role: 'user', content: user }], { maxTokens: 600, temperature: 0.2, signal });
         },
     });
-    async function runGovernedAgentAnswerForRun(request, repair) {
+    async function runGovernedAgentAnswerForRun(request, repair, route = 'generated_answer') {
         const governed = resolveGovernedAnswerRunner(projectRoot);
         const resolvedProvider = governed?.provider ?? null;
         const runner = governed?.runner ?? null;
@@ -376,6 +378,7 @@ export async function startLocalServer(opts) {
         let governedAnswer;
         let providerError;
         const isRepair = (repair?.attempt ?? 0) > 0 && Boolean(repair?.repairHint);
+        const reasoningEffort = resolveRunReasoningEffort(projectRoot, resolvedProvider, route, isRepair);
         const contextEnvelope = {
             mode: 'agent_run',
             selectedObject: request.selectedObject,
@@ -399,6 +402,7 @@ export async function startLocalServer(opts) {
                 cellId: `agent-run:${request.selectedObject?.kind ?? 'workspace'}:${request.selectedObject?.id ?? request.runId ?? 'auto'}`,
                 sql: JSON.stringify(contextEnvelope, null, 2),
             },
+            reasoningEffort,
             projectRoot,
             executeCertifiedBlock: executeCertifiedBlockForAgent,
             executeGeneratedSql: executeGeneratedSqlForAgent,
@@ -416,10 +420,10 @@ export async function startLocalServer(opts) {
         }
         return governedAnswer;
     }
-    const answerRunExecutor = async ({ request, routeDecision, attempt, repairHint, emitAnswerDelta }) => {
+    const answerRunExecutor = async ({ request, route, routeDecision, attempt, repairHint, emitAnswerDelta }) => {
         let governedAnswer;
         try {
-            governedAnswer = await runGovernedAgentAnswerForRun(request, { attempt, repairHint });
+            governedAnswer = await runGovernedAgentAnswerForRun(request, { attempt, repairHint }, route);
             // Surface the approved Hint-Graph corrections that shaped this answer so the
             // UI can show an "applied learnings" chip (memoryContext is already on the answer).
             if (!governedAnswer.appliedHints) {
@@ -1094,6 +1098,7 @@ export async function startLocalServer(opts) {
         let governedAnswer;
         let providerError;
         const memoOnly = input.mode === 'memo_only';
+        const reasoningEffort = resolveRunReasoningEffort(projectRoot, resolvedProvider, 'research', false);
         const contextEnvelope = {
             mode: 'app_research',
             generationMode: input.mode ?? 'sql_and_memo',
@@ -1141,6 +1146,7 @@ export async function startLocalServer(opts) {
                 cellId: `app-research:${input.appId}:${input.dashboardId ?? 'app'}`,
                 sql: JSON.stringify(contextEnvelope, null, 2),
             },
+            reasoningEffort,
             projectRoot,
             executeCertifiedBlock: executeCertifiedBlockForAgent,
             executeGeneratedSql: executeGeneratedSqlForAgent,
@@ -1327,6 +1333,7 @@ export async function startLocalServer(opts) {
                                     context,
                                 }, null, 2),
                             },
+                            reasoningEffort: resolveRunReasoningEffort(projectRoot, resolvedProvider, 'research', false),
                             projectRoot,
                             executeCertifiedBlock: executeCertifiedBlockForAgent,
                             executeGeneratedSql: executeGeneratedSqlForAgent,
@@ -2612,6 +2619,7 @@ export async function startLocalServer(opts) {
                     apiKey: typeof body.apiKey === 'string' ? body.apiKey : undefined,
                     baseUrl: typeof body.baseUrl === 'string' ? body.baseUrl : undefined,
                     model: typeof body.model === 'string' ? body.model : undefined,
+                    reasoningEffort: isReasoningEffortSetting(body.reasoningEffort) ? body.reasoningEffort : undefined,
                 });
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(serializeJSON({ ok: true, providers }));
@@ -2622,6 +2630,60 @@ export async function startLocalServer(opts) {
             }
             return;
         }
+        // ── Subscription OAuth (Claude Pro/Max, ChatGPT Plus/Pro) ──────────────
+        {
+            const authMatch = path.match(/^\/api\/auth\/(claude|codex)\/(start|status|signout)$/);
+            if (authMatch) {
+                const oauthProvider = authMatch[1];
+                const action = authMatch[2];
+                const info = oauthProvider === 'claude'
+                    ? { models: CLAUDE_OAUTH_MODELS, defaultModel: CLAUDE_OAUTH_DEFAULT_MODEL }
+                    : { models: CODEX_OAUTH_MODELS, defaultModel: CODEX_OAUTH_DEFAULT_MODEL };
+                const manager = getOAuthManager(projectRoot, oauthProvider);
+                const statusPayload = () => {
+                    const connected = oauthProvider === 'claude' ? claudeOAuthConnected(projectRoot) : codexOAuthConnected(projectRoot);
+                    return {
+                        provider: oauthProvider,
+                        connected,
+                        email: connected ? manager.getEmail() : null,
+                        models: info.models,
+                        defaultModel: info.defaultModel,
+                        pending: manager.isPending(),
+                    };
+                };
+                try {
+                    if (action === 'status' && req.method === 'GET') {
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(serializeJSON(statusPayload()));
+                        return;
+                    }
+                    if (action === 'signout' && req.method === 'POST') {
+                        manager.signOut();
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(serializeJSON(statusPayload()));
+                        return;
+                    }
+                    if (action === 'start' && req.method === 'POST') {
+                        // Begin a fresh flow: build the authorize URL and start the loopback
+                        // callback server. The client opens the URL; the server captures the
+                        // redirect and persists tokens. The pending state lives on the manager,
+                        // so a superseded flow settles cleanly. Errors surface on the next poll.
+                        const url = manager.startAuthorizationFlow();
+                        void manager.waitForCallback().catch(() => { });
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(serializeJSON({ url, ...statusPayload() }));
+                        return;
+                    }
+                    res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: 'Method not allowed' }));
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: error instanceof Error ? error.message : String(error) }));
+                }
+                return;
+            }
+        }
         if (req.method === 'POST' && path === '/api/settings/providers/test') {
             try {
                 const body = await readJSON(req);
@@ -5676,6 +5738,10 @@ export async function startLocalServer(opts) {
                     conversationContext: conversationContext && typeof conversationContext === 'object' && !Array.isArray(conversationContext)
                         ? conversationContext
                         : undefined,
+                    // Intentionally NOT threading a route effort here: this raw block/chat
+                    // authoring endpoint keeps each SDK runner's own tuned default (the
+                    // claude-agent-sdk runs `xhigh` for deep authoring). Governed answer /
+                    // research paths carry task-adaptive effort; this one shouldn't cap it.
                     projectRoot,
                     executeCertifiedBlock: executeCertifiedBlockForAgent,
                     executeGeneratedSql: executeGeneratedSqlForAgent,
@@ -6674,6 +6740,49 @@ function resolveGovernedAnswerRunner(projectRoot) {
     const runner = getLLMRunner(resolved);
     return runner ? { provider: resolved, runner } : null;
 }
+/** Map a runner provider id to the settings id whose reasoning ceiling applies. */
+function reasoningSettingsIdFor(provider) {
+    return provider === 'claude-agent-sdk' ? 'anthropic' : provider;
+}
+/** Type-guard for the reasoning-effort settings value from an untrusted request body. */
+function isReasoningEffortSetting(value) {
+    return value === 'auto' || value === 'low' || value === 'medium' || value === 'high';
+}
+// Per-project singleton OAuth managers — they hold pending-auth state that must
+// survive between the `/start` request and the loopback callback. Keyed by
+// project root. "Pending" is derived from the manager itself (isPending) so a
+// superseded double-start can't desync a separate flag.
+const claudeOAuthManagers = new Map();
+const codexOAuthManagers = new Map();
+function getOAuthManager(projectRoot, provider) {
+    if (provider === 'claude') {
+        let m = claudeOAuthManagers.get(projectRoot);
+        if (!m) {
+            m = new ClaudeOAuthManager(projectRoot);
+            claudeOAuthManagers.set(projectRoot, m);
+        }
+        return m;
+    }
+    let m = codexOAuthManagers.get(projectRoot);
+    if (!m) {
+        m = new CodexOAuthManager(projectRoot);
+        codexOAuthManagers.set(projectRoot, m);
+    }
+    return m;
+}
+/**
+ * Resolve the concrete reasoning effort for a run: the route's task-adaptive
+ * effort (bumped one level on a repair attempt), clamped by the provider's
+ * Settings ceiling (`auto` = no cap). Providers no-op when their model has no
+ * reasoning surface, so returning a concrete level here is always safe.
+ */
+function resolveRunReasoningEffort(projectRoot, provider, route, isRepair) {
+    const ceiling = getEffectiveProviderConfig(projectRoot, reasoningSettingsIdFor(provider)).reasoningEffort;
+    let desired = route ? routeReasoningEffort(route) : 'medium';
+    if (isRepair)
+        desired = bumpReasoningEffort(desired);
+    return ceiling ? clampReasoningEffort(desired, ceiling) : desired;
+}
 function loadAppDashboard(projectRoot, appId, dashboardId) {
     for (const p of findAppDocuments(projectRoot)) {
         const { document: app } = loadAppDocument(p);