@agent-native/core 0.221.0-same-host-mcp-20261027-20261027081850 → 0.221.0

package/dist/agent/engine/ai-sdk-engine.js

@@ -1,6 +1,6 @@
 import { ssrfSafeFetch } from "../../extensions/url-safety.js";
 import { clearProviderCredentialAuthFailure, readDeployCredentialEnv, recordProviderCredentialAuthFailure, } from "../../server/credential-provider.js";
-import { allowsSamplingParams, anthropicManualThinkingBudget, isGPTReasoningModel, isUnsetReasoningEffort, normalizeReasoningEffortForModel, supportsClaudeAdaptiveThinking, } from "../../shared/reasoning-effort.js";
+import { allowsSamplingParams, anthropicManualThinkingBudget, claudeAdaptiveThinking, isGPTReasoningModel, isUnsetReasoningEffort, normalizeReasoningEffortForModel, supportsClaudeAdaptiveThinking, } from "../../shared/reasoning-effort.js";
 import { isNodeRuntime } from "../../shared/runtime.js";
 import { AI_SDK_MODEL_CONFIG } from "../model-config.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./credential-errors.js";
@@ -317,7 +317,7 @@ class AISDKEngine {
                 if (explicitThinking || supportsClaudeAdaptiveThinking(opts.model)) {
                     providerOpts.anthropic = {
                         ...(providerOpts.anthropic ?? {}),
-                        thinking: explicitThinking ?? { type: "adaptive" },
+                        thinking: explicitThinking ?? claudeAdaptiveThinking(opts.model),
                         ...(explicitThinking
                             ? {}
                             : { outputConfig: { effort: reasoningEffort } }),
@@ -373,7 +373,7 @@ class AISDKEngine {
             // the model's own default level applies.
             providerOpts.anthropic = {
                 ...providerOpts.anthropic,
-                thinking: { type: "adaptive" },
+                thinking: claudeAdaptiveThinking(opts.model),
             };
         }
         // @ai-sdk/openai infers reasoning models from its own id prefixes, which

package/dist/agent/engine/anthropic-engine.js

@@ -1,5 +1,5 @@
 import { clearProviderCredentialAuthFailure, readDeployCredentialEnv, recordProviderCredentialAuthFailure, } from "../../server/credential-provider.js";
-import { allowsSamplingParams, anthropicManualThinkingBudget, isUnsetReasoningEffort, normalizeReasoningEffortForModel, supportsClaudeAdaptiveThinking, } from "../../shared/reasoning-effort.js";
+import { allowsSamplingParams, anthropicManualThinkingBudget, claudeAdaptiveThinking, isUnsetReasoningEffort, normalizeReasoningEffortForModel, supportsClaudeAdaptiveThinking, } from "../../shared/reasoning-effort.js";
 import { ANTHROPIC_MODEL_CONFIG } from "../model-config.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./credential-errors.js";
 import { describeErrorWithCauses, isBareProviderRejectionMessage, PROVIDER_TRANSIENT_REJECTION_ERROR_CODE, } from "./error-detail.js";
@@ -63,11 +63,11 @@ class AnthropicEngine {
             supportsClaudeAdaptiveThinking(opts.model)) {
             // No effort chosen: keep adaptive thinking on and send no effort, so
             // the model's own default level applies.
-            extra.thinking = { type: "adaptive" };
+            extra.thinking = claudeAdaptiveThinking(opts.model);
         }
         if (reasoningEffort && !extra.thinking) {
             if (supportsClaudeAdaptiveThinking(opts.model)) {
-                extra.thinking = { type: "adaptive" };
+                extra.thinking = claudeAdaptiveThinking(opts.model);
                 extra.output_config = { effort: reasoningEffort };
             }
             else {

package/dist/agent/engine/credential-owner.d.ts

@@ -5,5 +5,8 @@ import type { AgentEngine } from "./types.js";
  * connected (user, org, or workspace scoped).
  */
 export type EngineCredentialOwner = "builder" | "deployment" | "customer";
+export type EngineLlmConnectionSource = "app_secrets" | "settings" | "env";
 export declare function tagEngineCredentialOwner(engine: AgentEngine, owner: EngineCredentialOwner | undefined): void;
+export declare function tagEngineLlmConnectionSource(engine: AgentEngine, source: EngineLlmConnectionSource | undefined): void;
 export declare function getEngineCredentialOwner(engine: unknown): EngineCredentialOwner | undefined;
+export declare function getEngineLlmConnectionSource(engine: unknown): EngineLlmConnectionSource | undefined;

package/dist/agent/engine/credential-owner.js

@@ -1,7 +1,16 @@
 const owners = new WeakMap();
+const llmConnectionSources = new WeakMap();
 export function tagEngineCredentialOwner(engine, owner) {
     owners.set(engine, owner);
 }
+export function tagEngineLlmConnectionSource(engine, source) {
+    llmConnectionSources.set(engine, source);
+}
 export function getEngineCredentialOwner(engine) {
     return engine && typeof engine === "object" ? owners.get(engine) : undefined;
 }
+export function getEngineLlmConnectionSource(engine) {
+    return engine && typeof engine === "object"
+        ? llmConnectionSources.get(engine)
+        : undefined;
+}

package/dist/agent/engine/registry.js

@@ -12,7 +12,7 @@ import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../chatgpt-subscription-contra
 import { readDefaultAgentEngineSetting } from "../default-agent-engine.js";
 import { normalizeModelForEngine } from "../model-version.js";
 import { createProviderEndpointFetch } from "./ai-sdk-engine.js";
-import { tagEngineCredentialOwner, } from "./credential-owner.js";
+import { tagEngineCredentialOwner, tagEngineLlmConnectionSource, } from "./credential-owner.js";
 import { AI_SDK_ANTHROPIC_DEFAULT_BASE_URL, OLLAMA_DEFAULT_BASE_URL, OLLAMA_BASE_URL_ENV_VAR, OPENAI_BASE_URL_ENV_VAR, OPENAI_DEFAULT_BASE_URL, isCustomOpenAiBaseUrl, } from "./openai-compatible-endpoint.js";
 import { isLocalNetworkOllamaEndpoint, validateProviderBaseUrl, } from "./provider-endpoint-validation.js";
 const require = createRequire(import.meta.url);
@@ -607,6 +607,7 @@ async function resolveUsableProviderSecretDetailed(key) {
         value,
         provenance: {
             scope: source === "env" ? "deployment" : (source ?? "deployment"),
+            source: source === "env" ? "env" : "app_secrets",
             ...(resolved.scopeId ? { scopeId: resolved.scopeId } : {}),
         },
     };
@@ -687,13 +688,30 @@ export function credentialOwnerForEntry(entry, apiKey, provenance, config) {
     return provenance.scope === "deployment" ? "deployment" : "customer";
 }
 async function createEngineForEntry(...args) {
-    const { config, credentialOwner } = await engineCreateConfigForEntry(...args);
+    const { config, credentialOwner, connectionSource } = await engineCreateConfigForEntry(...args);
     const engine = args[0].create(config);
     tagEngineCredentialOwner(engine, credentialOwner);
+    tagEngineLlmConnectionSource(engine, connectionSource);
     return engine;
 }
+function connectionSourceForProvenance(provenance) {
+    if (provenance?.source === "app_secrets" ||
+        provenance?.source === "settings" ||
+        provenance?.source === "env") {
+        return provenance.source;
+    }
+    if (provenance?.scope === "deployment")
+        return "env";
+    if (provenance?.scope === "user" ||
+        provenance?.scope === "org" ||
+        provenance?.scope === "workspace") {
+        return "app_secrets";
+    }
+    return undefined;
+}
 async function engineCreateConfigForEntry(entry, apiKey, extra, credentialResolution = "explicit", apiKeyEnvVar, credentialIdentity, apiKeyProvenance) {
     const safeExtra = { ...(extra ?? {}) };
+    let connectionSource = connectionSourceForProvenance(apiKeyProvenance);
     if (entry.name === CHATGPT_SUBSCRIPTION_ENGINE_NAME) {
         const email = identityUserEmail(credentialIdentity);
         if (!email ||
@@ -756,6 +774,7 @@ async function engineCreateConfigForEntry(entry, apiKey, extra, credentialResolu
             matchingApiKeyProvenance ??= resolvedMatchingCredential?.provenance;
         }
     }
+    connectionSource ??= connectionSourceForProvenance(matchingApiKeyProvenance);
     const aiSdkProvider = entry.name.startsWith("ai-sdk:")
         ? entry.name.slice("ai-sdk:".length)
         : undefined;
@@ -837,11 +856,18 @@ async function engineCreateConfigForEntry(entry, apiKey, extra, credentialResolu
                 lane: creds.lane,
             };
         }
+        connectionSource =
+            creds.source === "env" ? "env" : creds.source ? "app_secrets" : undefined;
     }
     const config = engineCreateConfig(entry, matchingApiKey, safeExtra);
     return {
         config,
         credentialOwner: credentialOwnerForEntry(entry, matchingApiKey, matchingApiKeyProvenance, config),
+        connectionSource: connectionSource ??
+            (matchingApiKey === undefined &&
+                entry.requiredEnvVars.some((key) => canUseDeployCredentialFallbackForRequest(key))
+                ? "env"
+                : undefined),
     };
 }
 export function isStoredEngineUsable(stored, entry) {

package/dist/agent/harness/acp-adapter.d.ts

@@ -58,6 +58,7 @@ export declare function acpAutoPermissionDecision(kind: string | undefined, mode
  */
 export declare function selectAcpPermissionOption(options: AcpPermissionOption[], approved: boolean): string | undefined;
 export declare function resolveAcpWorkspacePath(cwd: string, requestedPath: string): string;
+export declare function resolveAcpResumeCwd(checkpointCwd: unknown, fallbackCwd: string): Promise<string>;
 interface AcpContentBlock {
     type: string;
     text?: string;

package/dist/agent/harness/acp-adapter.js

@@ -141,7 +141,10 @@ class AcpHarnessSession {
         });
         this.supportsLoad = Boolean(initResponse?.agentCapabilities?.loadSession);
         const resume = opts.resumeState;
-        if (resume?.sessionId && this.supportsLoad) {
+        if (typeof resume?.sessionId === "string" &&
+            resume.sessionId.length > 0 &&
+            this.supportsLoad) {
+            this.cwd = await resolveAcpResumeCwd(resume.cwd, this.cwd);
             try {
                 await this.connection.loadSession({
                     sessionId: resume.sessionId,
@@ -203,15 +206,23 @@ class AcpHarnessSession {
         });
         yield* queue;
     }
-    async approve(approval) {
+    approve(approval) {
         const pending = this.pendingPermissions.get(approval.id);
-        if (!pending)
-            return;
+        if (!pending) {
+            throw new Error(`[acp-harness] Approval ${approval.id} is not pending in this process.`);
+        }
         this.pendingPermissions.delete(approval.id);
         pending.resolve(buildAcpPermissionResponse(pending.options, approval.approved));
+        return Promise.resolve();
+    }
+    canResolveApproval(approval) {
+        return this.pendingPermissions.has(approval.id);
+    }
+    async checkpoint() {
+        return { sessionId: this.acpSessionId, cwd: this.cwd };
     }
     async detach() {
-        const state = { sessionId: this.acpSessionId, cwd: this.cwd };
+        const state = await this.checkpoint();
         await this.destroy();
         return state;
     }
@@ -547,6 +558,26 @@ export function resolveAcpWorkspacePath(cwd, requestedPath) {
     }
     return abs;
 }
+export async function resolveAcpResumeCwd(checkpointCwd, fallbackCwd) {
+    if (checkpointCwd === undefined || checkpointCwd === null) {
+        return path.resolve(fallbackCwd);
+    }
+    if (typeof checkpointCwd !== "string" || !path.isAbsolute(checkpointCwd)) {
+        throw new Error("[acp-harness] Checkpoint working directory must be an absolute path.");
+    }
+    const cwd = path.resolve(checkpointCwd);
+    let stats;
+    try {
+        stats = await fs.stat(cwd);
+    }
+    catch (error) {
+        throw new Error(`[acp-harness] Checkpoint working directory is not accessible: ${cwd}`, { cause: error });
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`[acp-harness] Checkpoint working directory is not a directory: ${cwd}`);
+    }
+    return cwd;
+}
 function sliceTextFile(content, line, limit) {
     if (line == null && limit == null)
         return content;

package/dist/agent/harness/background.d.ts

@@ -1,7 +1,11 @@
 import type { BackgroundAgentControlResult, BackgroundAgentController } from "../../code-agents/background-controller.js";
 import type { BackgroundAgentRun, BackgroundAgentTranscriptEvent, ListBackgroundAgentRunsOptions } from "../../code-agents/background-run.js";
+import type { ActiveRun } from "../run-manager.js";
 import { type AgentHarnessOwnerScope } from "./lifecycle.js";
-export declare function createAgentHarnessBackgroundAgentController(scope?: AgentHarnessOwnerScope): BackgroundAgentController;
+export declare function createAgentHarnessBackgroundAgentController(scope?: AgentHarnessOwnerScope, options?: {
+    /** Hosts use this to project child output and drain queued thread work. */
+    onRunComplete?: (run: ActiveRun) => void | Promise<void>;
+}): BackgroundAgentController;
 export declare const agentHarnessBackgroundAgentController: BackgroundAgentController;
 export declare function listAgentHarnessBackgroundRuns(options?: ListBackgroundAgentRunsOptions & {
     orgId?: string | null;

package/dist/agent/harness/background.js

@@ -3,7 +3,7 @@ import { abortRunDurably } from "../run-manager.js";
 import { getRunEventsSince } from "../run-store.js";
 import { resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopAndPersistAgentHarnessSession, } from "./lifecycle.js";
 import { getAgentHarnessSessionByRunId, listAgentHarnessSessionEvents, listAgentHarnessSessions, } from "./store.js";
-export function createAgentHarnessBackgroundAgentController(scope = { ownerEmail: null }) {
+export function createAgentHarnessBackgroundAgentController(scope = { ownerEmail: null }, options = {}) {
     return {
         list: (options) => listAgentHarnessBackgroundRuns({
             ...options,
@@ -12,7 +12,7 @@ export function createAgentHarnessBackgroundAgentController(scope = { ownerEmail
         }),
         get: (runId) => getAgentHarnessBackgroundRun(runId, scope),
         transcript: (runId) => listAgentHarnessBackgroundTranscriptEvents(runId, scope),
-        sendFollowUp: (input) => sendAgentHarnessBackgroundFollowUp(input, scope),
+        sendFollowUp: (input) => sendAgentHarnessBackgroundFollowUp(input, scope, options.onRunComplete),
         control: (input) => controlAgentHarnessBackgroundRun(input, scope),
     };
 }
@@ -341,12 +341,13 @@ function backgroundStatus(status, needsApproval) {
         return "completed";
     return "unknown";
 }
-async function sendAgentHarnessBackgroundFollowUp(input, scope) {
+async function sendAgentHarnessBackgroundFollowUp(input, scope, onRunComplete) {
     const result = await sendAgentHarnessFollowUp({
         runId: input.runId,
         prompt: input.prompt,
         metadata: input.metadata,
         scope,
+        onRunComplete,
     });
     const run = await getAgentHarnessBackgroundRun(input.runId, scope);
     return {

package/dist/agent/harness/lifecycle.d.ts

@@ -1,3 +1,4 @@
+import type { ActiveRun } from "../run-manager.js";
 import { type StoredAgentHarnessSession } from "./store.js";
 import type { AgentHarnessAdapter, AgentHarnessApproval, AgentHarnessCreateSessionOptions, AgentHarnessEvent, AgentHarnessSession } from "./types.js";
 export type AgentHarnessLifecycleErrorCode = "not_found" | "owner_mismatch" | "approval_mismatch" | "unavailable" | "invalid_input";
@@ -39,6 +40,7 @@ export declare function sendAgentHarnessFollowUp(input: {
     scope: AgentHarnessOwnerScope;
     metadata?: Record<string, unknown>;
     onHarnessEvent?: (event: AgentHarnessEvent) => void | Promise<void>;
+    onRunComplete?: (run: ActiveRun) => void | Promise<void>;
 }): Promise<AgentHarnessLifecycleResult>;
 export declare function stopLiveAgentHarnessSession(input: {
     sessionId: string;