@agent-native/core 0.157.6 → 0.157.8

package/dist/agent/harness/background.js

@@ -98,7 +98,7 @@ function toAgentHarnessBackgroundRun(session) {
         },
         title: `${session.harnessName} harness`,
         subtitle: session.status === "running" ? "Running" : undefined,
-        status: backgroundStatus(session.status),
+        status: backgroundStatus(session.status, Boolean(session.pendingApproval)),
         phase: session.status,
         createdAt,
         updatedAt,
@@ -218,14 +218,17 @@ function parseRunEvent(row) {
         return null;
     }
 }
-function backgroundStatus(status) {
+function backgroundStatus(status, needsApproval) {
     if (status === "running")
         return "running";
     if (status === "errored")
         return "errored";
-    if (status === "idle" || status === "stopped" || status === "destroyed") {
+    if (needsApproval)
+        return "needs-approval";
+    if (status === "idle")
+        return "paused";
+    if (status === "stopped" || status === "destroyed")
         return "completed";
-    }
     return "unknown";
 }
 async function sendAgentHarnessBackgroundFollowUp(input, scope) {
@@ -253,7 +256,9 @@ async function controlAgentHarnessBackgroundRun(input, scope) {
     }
     if (input.command === "approve" || input.command === "deny") {
         const session = await getAgentHarnessSessionByRunId(input.runId);
-        if (!session || session.ownerEmail !== scope.ownerEmail) {
+        if (!session ||
+            session.ownerEmail !== scope.ownerEmail ||
+            (scope.orgId !== undefined && session.orgId !== scope.orgId)) {
             return missingHarnessRunResult(input.runId);
         }
         const pending = session.pendingApproval;

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

@@ -0,0 +1,20 @@
+import type { AgentNativeHarnessRuntime } from "../../config.js";
+export type HostedHarnessRuntime = AgentNativeHarnessRuntime;
+export declare const HOSTED_HARNESS_ENV_KEY: "AGENT_NATIVE_HOSTED_HARNESS";
+export declare const HOSTED_HARNESS_ORG_SETTING_KEY: "agent-harness.enabled";
+export declare const HOSTED_HARNESS_RUNTIME_ORDER: readonly HostedHarnessRuntime[];
+export declare const HOSTED_HARNESS_AGENT_DESCRIPTIONS: Record<HostedHarnessRuntime, string>;
+export declare const HOSTED_HARNESS_AGENT_LABELS: Record<HostedHarnessRuntime, string>;
+export declare const HOSTED_HARNESS_BLOCKED_TOOL_NAMES: Set<string>;
+export declare function isHostedHarnessRuntime(value: unknown): value is HostedHarnessRuntime;
+export declare function normalizeHostedHarnessRuntime(value: unknown): HostedHarnessRuntime | undefined;
+export declare function normalizeHostedHarnessRuntimes(value: unknown): HostedHarnessRuntime[];
+export declare function isHostedHarnessConfigured(value: unknown): boolean;
+export declare function hostedHarnessAgentOption(runtime: HostedHarnessRuntime): {
+    id: AgentNativeHarnessRuntime;
+    label: string;
+    description: string;
+};
+export declare function isHostedHarnessBlockedToolName(name: string): boolean;
+export declare function filterHostedHarnessToolNames(names: readonly string[]): string[];
+export declare function hostedHarnessSystemPrompt(runtime: HostedHarnessRuntime): string;

package/dist/agent/harness/hosted.js

@@ -0,0 +1,100 @@
+export const HOSTED_HARNESS_ENV_KEY = "AGENT_NATIVE_HOSTED_HARNESS";
+export const HOSTED_HARNESS_ORG_SETTING_KEY = "agent-harness.enabled";
+export const HOSTED_HARNESS_RUNTIME_ORDER = [
+    "claude-code",
+    "codex",
+    "pi",
+    "opencode",
+];
+export const HOSTED_HARNESS_AGENT_DESCRIPTIONS = {
+    "claude-code": "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+    codex: "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+    pi: "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+    opencode: "Production mode is tools-only: no repository, shell, or code editing. Use the Electron app for full coding workflows.",
+};
+export const HOSTED_HARNESS_AGENT_LABELS = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    pi: "Pi",
+    opencode: "OpenCode",
+};
+export const HOSTED_HARNESS_BLOCKED_TOOL_NAMES = new Set([
+    "bash",
+    "edit",
+    "read",
+    "write",
+    "run-code",
+    "tool-orchestration",
+    "get-code-execution",
+    "read-file",
+    "write-file",
+    "read-local-file",
+    "write-local-file",
+    "apply-source-edit",
+    "update-file",
+    "delete-file",
+    "github-repo-list-files",
+    "github-repo-read-file",
+    "github-repo-search-code",
+    "github-repo-write-file",
+    "github-repo-delete-file",
+    "save-data-program",
+    "preview-data-program",
+    "run-data-program",
+    "list-data-programs",
+    "get-data-program",
+    "delete-data-program",
+    "workspace-files",
+    "show-workspace-file",
+    "read-workspace-file",
+    "write-workspace-file",
+    "delete-workspace-file",
+    "grep-workspace-file",
+    "connect-builder",
+]);
+export function isHostedHarnessRuntime(value) {
+    return (value === "claude-code" ||
+        value === "codex" ||
+        value === "pi" ||
+        value === "opencode");
+}
+export function normalizeHostedHarnessRuntime(value) {
+    if (value === "claude")
+        return "claude-code";
+    return isHostedHarnessRuntime(value) ? value : undefined;
+}
+export function normalizeHostedHarnessRuntimes(value) {
+    if (!Array.isArray(value))
+        return [...HOSTED_HARNESS_RUNTIME_ORDER];
+    const runtimes = value
+        .map((runtime) => normalizeHostedHarnessRuntime(runtime))
+        .filter((runtime) => runtime !== undefined);
+    return [...new Set(runtimes)];
+}
+export function isHostedHarnessConfigured(value) {
+    return (value === true ||
+        (!!value && typeof value === "object" && !Array.isArray(value)));
+}
+export function hostedHarnessAgentOption(runtime) {
+    return {
+        id: runtime,
+        label: HOSTED_HARNESS_AGENT_LABELS[runtime],
+        description: HOSTED_HARNESS_AGENT_DESCRIPTIONS[runtime],
+    };
+}
+export function isHostedHarnessBlockedToolName(name) {
+    return (HOSTED_HARNESS_BLOCKED_TOOL_NAMES.has(name) ||
+        name.startsWith("workspace-file-") ||
+        name.startsWith("data-program-"));
+}
+export function filterHostedHarnessToolNames(names) {
+    return names.filter((name) => !isHostedHarnessBlockedToolName(name));
+}
+export function hostedHarnessSystemPrompt(runtime) {
+    return `<hosted-tools-only-harness runtime="${runtime}">
+You are running as a hosted ${HOSTED_HARNESS_AGENT_LABELS[runtime]} inside a production app.
+This is a tools-only mode. You have no repository, shell, filesystem, code-editing, or code-execution tools.
+Use the app's typed actions and SQL-backed resources for mail, calendar, analytics, and working state.
+For full coding work, tell the user to use the Agent Native Electron app.
+</hosted-tools-only-harness>`;
+}

package/dist/agent/harness/runner.js

@@ -6,92 +6,115 @@ export function startAgentHarnessRun(opts) {
     let harnessSession = opts.session;
     const detachOnComplete = opts.detachOnComplete !== false;
     return startRun(opts.runId, opts.threadId, async (send, signal) => {
-        send({
-            type: "activity",
-            label: `Starting ${opts.adapter.label}`,
-            tool: "harness",
-        });
-        harnessSession ??= await opts.adapter.createSession({
-            ...(opts.createSession ?? {}),
-            threadId: opts.threadId,
-            runId: opts.runId,
-            ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
-            orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-            signal,
-        });
-        await saveAgentHarnessSession({
-            id: opts.createSession?.sessionId ?? harnessSession.id,
-            harnessName: opts.adapter.name,
-            threadId: opts.threadId,
-            runId: opts.runId,
-            providerSessionId: harnessSession.id,
-            status: "running",
-            resumeState: opts.createSession?.resumeState,
-            ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
-            orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-        });
-        const storedSessionId = opts.createSession?.sessionId ?? harnessSession.id;
-        registerLiveAgentHarnessSession({
-            sessionId: storedSessionId,
-            adapter: opts.adapter,
-            session: harnessSession,
-            createSession: opts.createSession,
-            ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
-            orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-        });
-        const input = {
-            ...opts.input,
-            abortSignal: signal,
-        };
-        let pendingApproval = null;
-        for await (const event of harnessSession.streamTurn(input)) {
-            if (signal.aborted)
-                break;
-            await opts.onHarnessEvent?.(event);
-            if (event.type === "approval-request") {
-                pendingApproval = event;
-                await updateAgentHarnessSession(opts.createSession?.sessionId ?? harnessSession.id, {
-                    status: "idle",
-                    pendingApproval: event,
-                });
+        let storedSessionId;
+        let keepLiveSession = false;
+        try {
+            send({
+                type: "activity",
+                label: `Starting ${opts.adapter.label}`,
+                tool: "harness",
+            });
+            harnessSession ??= await opts.adapter.createSession({
+                ...(opts.createSession ?? {}),
+                threadId: opts.threadId,
+                runId: opts.runId,
+                ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
+                orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
+                signal,
+            });
+            storedSessionId = opts.createSession?.sessionId ?? harnessSession.id;
+            await saveAgentHarnessSession({
+                id: storedSessionId,
+                harnessName: opts.adapter.name,
+                threadId: opts.threadId,
+                runId: opts.runId,
+                providerSessionId: harnessSession.id,
+                status: "running",
+                resumeState: opts.createSession?.resumeState,
+                ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
+                orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
+            });
+            registerLiveAgentHarnessSession({
+                sessionId: storedSessionId,
+                adapter: opts.adapter,
+                session: harnessSession,
+                createSession: opts.createSession,
+                ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
+                orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
+            });
+            const input = {
+                ...opts.input,
+                abortSignal: signal,
+            };
+            let pendingApproval = null;
+            for await (const event of harnessSession.streamTurn(input)) {
+                if (signal.aborted)
+                    break;
+                await opts.onHarnessEvent?.(event);
+                if (event.type === "approval-request") {
+                    pendingApproval = event;
+                    await updateAgentHarnessSession(storedSessionId, {
+                        status: "idle",
+                        pendingApproval: event,
+                    });
+                }
+                if (event.type === "error") {
+                    throw new Error(event.error);
+                }
+                for (const chatEvent of agentHarnessEventToAgentChatEvents(event)) {
+                    send(chatEvent);
+                }
             }
-            if (event.type === "error") {
-                throw new Error(event.error);
+            if (signal.aborted) {
+                await stopHarnessSession(harnessSession);
+                releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+                await markAgentHarnessSessionStopped(storedSessionId, "stopped");
+                return;
             }
-            for (const chatEvent of agentHarnessEventToAgentChatEvents(event)) {
-                send(chatEvent);
+            if (pendingApproval) {
+                const stored = await getAgentHarnessSession(storedSessionId);
+                const stillPending = stored?.pendingApproval &&
+                    typeof stored.pendingApproval === "object" &&
+                    "id" in stored.pendingApproval &&
+                    stored.pendingApproval.id === pendingApproval.id;
+                if (stillPending) {
+                    keepLiveSession = true;
+                    await updateAgentHarnessSession(storedSessionId, {
+                        status: "idle",
+                        pendingApproval,
+                    });
+                    return;
+                }
+            }
+            let resumeState = opts.createSession?.resumeState;
+            if (detachOnComplete && harnessSession.detach) {
+                resumeState = await harnessSession.detach();
             }
-        }
-        if (signal.aborted) {
-            await stopHarnessSession(harnessSession);
             releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
-            await markAgentHarnessSessionStopped(opts.createSession?.sessionId ?? harnessSession.id, "stopped");
-            return;
+            await updateAgentHarnessSession(storedSessionId, {
+                status: "idle",
+                resumeState,
+                pendingApproval: null,
+            });
         }
-        if (pendingApproval) {
-            const stored = await getAgentHarnessSession(storedSessionId);
-            const stillPending = stored?.pendingApproval &&
-                typeof stored.pendingApproval === "object" &&
-                "id" in stored.pendingApproval &&
-                stored.pendingApproval.id === pendingApproval.id;
-            if (stillPending) {
+        catch (error) {
+            if (harnessSession && !keepLiveSession) {
+                await stopHarnessSession(harnessSession).catch(() => undefined);
+            }
+            if (storedSessionId) {
+                releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
                 await updateAgentHarnessSession(storedSessionId, {
-                    status: "idle",
-                    pendingApproval,
-                });
-                return;
+                    status: "errored",
+                    pendingApproval: null,
+                }).catch(() => undefined);
             }
+            throw error;
         }
-        let resumeState = opts.createSession?.resumeState;
-        if (detachOnComplete && harnessSession.detach) {
-            resumeState = await harnessSession.detach();
+        finally {
+            if (!keepLiveSession && storedSessionId) {
+                releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+            }
         }
-        releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
-        await updateAgentHarnessSession(opts.createSession?.sessionId ?? harnessSession.id, {
-            status: "idle",
-            resumeState,
-            pendingApproval: null,
-        });
     }, opts.onRunComplete, {
         ...(opts.runOptions ?? {}),
         turnId: opts.turnId ?? opts.runOptions?.turnId,

package/dist/agent/observational-memory/observer.js

@@ -31,6 +31,18 @@ export async function runObserver(options) {
         threadId: options.threadId,
     });
     const startIndex = observedThrough + 1;
+    // The cursor is a position in whatever array the previous pass observed. The
+    // live agent loop passes the engine array, where each tool result is its own
+    // entry; other callers pass the store-derived array, which folds those into
+    // their tool-call parts and runs several times shorter. A cursor past the end
+    // of THIS array is a basis mismatch, not an up-to-date thread: the window can
+    // never become non-empty again, so the thread silently stops accruing memory.
+    // Measured in production — 17 of 19 threads carry a cursor above their stored
+    // message count, one at 57 against 9.
+    if (startIndex > options.messages.length) {
+        console.warn(`[observational-memory] thread ${options.threadId}: cursor ${observedThrough} is past the end of this ${options.messages.length}-message window, so nothing can be observed on this basis.`);
+        return { observed: false, unobservedTokens: 0 };
+    }
     const unobserved = options.messages.slice(startIndex);
     if (unobserved.length === 0) {
         return { observed: false, unobservedTokens: 0 };

package/dist/agent/production-agent.d.ts

@@ -1,6 +1,7 @@
 import type { EventHandler as H3EventHandler } from "h3";
 import type { Task } from "../a2a/types.js";
 import { type ActionAutomationContext, type ActionCaller } from "../action.js";
+import type { AgentNativeHarnessSetting } from "../config.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { type ReasoningEffort } from "../shared/reasoning-effort.js";
 import { type ResolveEngineConfig } from "./engine/index.js";
@@ -299,6 +300,8 @@ export interface ProductionAgentOptions {
     model?: string;
     /** App/template id used for org-scoped per-app model defaults. */
     appId?: string;
+    /** Static app capability for the hosted tools-only harness picker. */
+    hostedHarnessConfig?: AgentNativeHarnessSetting;
     /** Default effort for requests that do not supply an override. */
     reasoningEffort?: ReasoningEffort;
     /** Provider-specific options passed through to the engine */

package/dist/agent/production-agent.js

@@ -16,6 +16,7 @@ import { completeRun as completeProgressRun, startRun as startProgressRun, updat
 import { isRuntimeVisibleScope, parseSkillFrontmatter, } from "../server/agent-chat/skill-frontmatter.js";
 import { canUseDeployCredentialFallbackForRequest, getProviderCredentialAuthFailure, readDeployCredentialEnv, } from "../server/credential-provider.js";
 import { readBody } from "../server/h3-helpers.js";
+import { resolveHostedHarnessPolicy } from "../server/hosted-harness-policy.js";
 import { assertRequestActionSurfaceIsolation, getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { isReasoningEffort, normalizeReasoningEffortForRequest, stepDownReasoningEffort, } from "../shared/reasoning-effort.js";
@@ -33,6 +34,7 @@ import { PROVIDER_TO_ENV } from "./engine/provider-env-vars.js";
 import { loadPriorTurnToolCallJournal } from "./engine/tool-call-journal-seed.js";
 import { backfillEngineMessagesToolResults, stringifyToolUseInputForGateway, unmatchedToolResultReplayText, } from "./engine/translate-anthropic.js";
 import { EngineError } from "./engine/types.js";
+import { filterHostedHarnessToolNames, normalizeHostedHarnessRuntime, } from "./harness/hosted.js";
 import { getDefaultMaxIterations, getDefaultMaxRunInputTokens, MAX_AGENT_MAX_ITERATIONS, MIN_AGENT_MAX_ITERATIONS, normalizeMaxIterations, normalizeMaxRunInputTokens, readAgentLoopSettings, } from "./loop-settings.js";
 import { maybeCompactThread, buildObservationalContext, hasObservationalMemory, serializeObservationalMemoryBlock, } from "./observational-memory/index.js";
 import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js";
@@ -5056,7 +5058,7 @@ export async function runAgentLoop(opts) {
             // the user-visible turn.
             if (opts.ownerEmail) {
                 const compactThreadId = opts.threadId;
-                void maybeCompactThread({
+                const compaction = maybeCompactThread({
                     threadId: compactThreadId,
                     ownerEmail: opts.ownerEmail,
                     orgId: opts.orgId ?? null,
@@ -5064,6 +5066,17 @@ export async function runAgentLoop(opts) {
                 }).catch((err) => {
                     console.warn("[observational-memory] post-turn compaction skipped:", err instanceof Error ? err.message : String(err));
                 });
+                // This pass has to finish a streaming model call before it writes, and
+                // it starts after the turn's `done` event — on a host that freezes the
+                // isolate once the response settles, an unregistered promise is simply
+                // killed, so the thread never accrues the memory that would spare the
+                // next turn. Hand it to the platform keep-alive where there is one;
+                // long-lived hosts keep the existing fire-and-forget behavior.
+                const waitUntil = getRequestRunContext()?.waitUntil;
+                if (waitUntil)
+                    waitUntil(compaction);
+                else
+                    void compaction;
             }
         }
     }
@@ -6135,7 +6148,7 @@ export function createProductionAgentHandler(options) {
                 return { error: "Invalid request body" };
             }
         }
-        const { message, history = [], structuredHistory, references = [], threadId, attachments, displayMessage, queuedMessageId, internalContinuation, turnId: requestTurnId, model: requestModel, engine: requestEngine, effort: requestEffort, browserTabId, scope, trackInRunsTray, } = body;
+        const { message, history = [], structuredHistory, references = [], threadId, attachments, displayMessage, queuedMessageId, internalContinuation, turnId: requestTurnId, model: requestModel, engine: requestEngine, effort: requestEffort, browserTabId, scope, harness: requestHarness, trackInRunsTray, } = body;
         setupMark("bodyParsed");
         // Durable-background marker. Present ONLY when this handler was re-entered
         // as the Netlify background worker via the `_process-run` self-dispatch
@@ -6258,7 +6271,36 @@ export function createProductionAgentHandler(options) {
                 requestAttachments = preparedRequest.attachments;
             }
         }
-        const availableRequestActions = getRequestActions();
+        const requestedHostedHarness = normalizeHostedHarnessRuntime(requestHarness?.runtime);
+        if (requestHarness !== undefined && !requestedHostedHarness) {
+            setResponseStatus(event, 400);
+            return { error: "Unsupported hosted harness runtime" };
+        }
+        const hostedHarnessPolicy = requestedHostedHarness
+            ? await resolveHostedHarnessPolicy({
+                config: options.hostedHarnessConfig,
+                orgId: getRequestOrgId() ?? null,
+                userEmail: ownerEmail,
+            })
+            : null;
+        if (requestedHostedHarness &&
+            (!hostedHarnessPolicy?.enabled ||
+                !hostedHarnessPolicy.runtimes.includes(requestedHostedHarness))) {
+            setResponseStatus(event, hostedHarnessPolicy?.configEnabled ? 403 : 404);
+            return {
+                error: hostedHarnessPolicy?.configEnabled
+                    ? "Hosted harness is not enabled for this organization"
+                    : "Hosted harness is not configured for this app",
+            };
+        }
+        const runContext = ensureRequestRunContext();
+        if (runContext && requestedHostedHarness) {
+            runContext.hostedHarnessRuntime = requestedHostedHarness;
+        }
+        let availableRequestActions = getRequestActions();
+        if (requestedHostedHarness) {
+            availableRequestActions = filterActionsByAllowedNames(availableRequestActions, filterHostedHarnessToolNames(Object.keys(availableRequestActions)));
+        }
         let surfacedRequestActions = availableRequestActions;
         if (options.resolveActionSurface) {
             const persistedSurface = isBackgroundWorker
@@ -6276,6 +6318,9 @@ export function createProductionAgentHandler(options) {
                     availableActionNames: Object.keys(availableRequestActions),
                 });
             surfacedRequestActions = filterActionsByAllowedNames(availableRequestActions, surface.allowedActionNames);
+            if (requestedHostedHarness) {
+                surfacedRequestActions = filterActionsByAllowedNames(surfacedRequestActions, filterHostedHarnessToolNames(Object.keys(surfacedRequestActions)));
+            }
             const allowedNames = Object.keys(surfacedRequestActions);
             const runCtx = ensureRequestRunContext();
             if (runCtx)
@@ -6604,8 +6649,9 @@ export function createProductionAgentHandler(options) {
         // is unrelated to the app's job (e.g. a voice-first macro tracker).
         const filesContextThunk = () => (async () => {
             let filesContext = "";
-            if (options.skipFilesContext)
+            if (options.skipFilesContext || requestedHostedHarness) {
                 return filesContext;
+            }
             if (history.length === 0) {
                 try {
                     const { resourceListAccessible, SHARED_OWNER, WORKSPACE_OWNER, resourceGet, } = await import("../resources/store.js");
@@ -6963,6 +7009,30 @@ export function createProductionAgentHandler(options) {
                 // Keep the body-derived messages — never drop the run.
             }
         }
+        // A foreground turn on an existing thread that arrives with NO history is
+        // amnesia, not a new conversation — the client trims history against a size
+        // budget and one tool-heavy turn could zero it out, which reads downstream
+        // as an ordinary first message. Recover what was said from the stored
+        // thread. Runs only on the foreground path, before `onRunPrepared` persists
+        // this turn, so the recovered window cannot contain the current message.
+        if (!isBackgroundWorker &&
+            !internalContinuation &&
+            threadId &&
+            historyMessages.length === 0) {
+            try {
+                const { getThread } = await import("../chat-threads/store.js");
+                const { recoverThreadHistoryForRequest } = await import("./thread-data-builder.js");
+                const recovered = recoverThreadHistoryForRequest((await getThread(threadId))?.threadData);
+                if (recovered.length > 0)
+                    messages.unshift(...recovered);
+            }
+            catch (err) {
+                // Never drop the run over this — but never let it pass for "the thread
+                // had nothing to recover" either. That silence is the same failure this
+                // block exists to fix, one layer down.
+                console.warn(`[agent-chat] history recovery failed for thread ${threadId}; continuing with no prior context:`, err);
+            }
+        }
         setupMark("depsThread");
         // DIAGNOSTIC-ONLY: owner/thread resolution + runId/effectiveThreadId +
         // chained-continuation thread fetch finished.

package/dist/agent/thread-data-builder.d.ts

@@ -73,6 +73,18 @@ export declare function normalizeThreadRepository(repo: any): any;
  * Originally inlined in `integrations/webhook-handler.ts`.
  */
 export declare function threadDataToEngineMessages(threadData: string | Record<string, unknown> | null | undefined): EngineMessage[];
+/**
+ * The trailing window of what was actually said in a thread, for a request that
+ * arrived carrying no history of its own. The client trims history against a
+ * size budget, so one tool-heavy turn can zero it out; without this floor the
+ * model re-derives answers it already gave and re-asks questions the user
+ * already answered. Contiguous and bounded on purpose — this restores the
+ * conversation, not the tool transcript.
+ */
+export declare function recoverThreadHistoryForRequest(threadData: string | Record<string, unknown> | null | undefined, limits?: {
+    maxMessages?: number;
+    maxChars?: number;
+}): EngineMessage[];
 /**
  * Select the participant-visible delivery for integration turns while keeping
  * a compact, trusted resource ledger available to the agent. Raw tool results

package/dist/agent/thread-data-builder.js

@@ -671,6 +671,29 @@ export function threadDataToEngineMessages(threadData) {
     }
     return messages;
 }
+const MAX_RECOVERED_HISTORY_MESSAGES = 12;
+const MAX_RECOVERED_HISTORY_CHARS = 32_000;
+function engineMessageTextLength(message) {
+    return message.content.reduce((total, part) => total + (part.type === "text" ? (part.text?.length ?? 0) : 0), 0);
+}
+/**
+ * The trailing window of what was actually said in a thread, for a request that
+ * arrived carrying no history of its own. The client trims history against a
+ * size budget, so one tool-heavy turn can zero it out; without this floor the
+ * model re-derives answers it already gave and re-asks questions the user
+ * already answered. Contiguous and bounded on purpose — this restores the
+ * conversation, not the tool transcript.
+ */
+export function recoverThreadHistoryForRequest(threadData, limits) {
+    const maxMessages = limits?.maxMessages ?? MAX_RECOVERED_HISTORY_MESSAGES;
+    const maxChars = limits?.maxChars ?? MAX_RECOVERED_HISTORY_CHARS;
+    const window = threadDataToEngineMessages(threadData).slice(-maxMessages);
+    let total = window.reduce((sum, message) => sum + engineMessageTextLength(message), 0);
+    while (window.length > 1 && total > maxChars) {
+        total -= engineMessageTextLength(window.shift());
+    }
+    return window;
+}
 const MAX_INTEGRATION_ARTIFACTS_IN_CONTEXT = 12;
 const MAX_INTEGRATION_ARTIFACT_FIELD_CHARS = 500;
 function boundedString(value) {

package/dist/agent/types.d.ts

@@ -129,6 +129,10 @@ export interface AgentChatScope {
     id: string;
     label?: string;
 }
+export interface AgentChatHarnessRequest {
+    /** Hosted tools-only runtime selected in the production app picker. */
+    runtime: "claude-code" | "codex" | "pi" | "opencode";
+}
 export interface AgentChatRequest {
     message: string;
     /** Stable identity of a durable queued message, used to reject replayed delivery. */
@@ -217,6 +221,8 @@ export interface AgentChatRequest {
     browserTabId?: string;
     /** Resource scope for this chat thread, e.g. the deck currently bound to the tab. */
     scope?: AgentChatScope | null;
+    /** Optional hosted tools-only harness selection. */
+    harness?: AgentChatHarnessRequest;
     /** When true, expose this chat turn as a user-visible run in RunsTray. */
     trackInRunsTray?: boolean;
     /**

package/dist/client/AgentPanel.d.ts

@@ -175,6 +175,10 @@ export interface AgentSidebarProps {
     imageModelMenu?: AssistantChatProps["imageModelMenu"];
     /** Local or hosted agent runtimes shown above the model list. */
     availableAgents?: AssistantChatProps["availableAgents"];
+    /** Host-provided model catalog used by native chat surfaces. */
+    availableModels?: AssistantChatProps["availableModels"];
+    /** Whether the host-provided model catalog is still loading. */
+    modelListLoading?: AssistantChatProps["modelListLoading"];
     /** Selected agent runtime identifier. */
     selectedAgent?: AssistantChatProps["selectedAgent"];
     /** Callback when the user picks an agent runtime. */
@@ -246,7 +250,7 @@ export interface AgentSidebarProps {
  * Wraps app content with a toggleable agent sidebar.
  * Use AgentToggleButton in your header to open/close it.
  */
-export declare function AgentSidebar({ children, emptyStateText, suggestions, dynamicSuggestions, composerToolbarSlot, composerSlot, onComposerTextChange, imageModelMenu, availableAgents, selectedAgent, onAgentChange, onConnectLocalRuntime, runtime, adapterReloadKey, threadFooterSlot, defaultSidebarWidth, sidebarWidth, position, defaultOpen, animateMobile, animateDesktop, chatViewTransition, chatViewTransitionHandoff, storageKey, openStorageKey, apiUrl, agentChatSurface, showTabBar, suppressInlineOpenApp, composerPlaceholder, openOnChatRunning, onFullscreenRequest, scope, showScopeBadge, browserTabId, threadUrlSync, agentPageHref, suppressFirstRunOnboarding, }: AgentSidebarProps): React.JSX.Element;
+export declare function AgentSidebar({ children, emptyStateText, suggestions, dynamicSuggestions, composerToolbarSlot, composerSlot, onComposerTextChange, imageModelMenu, availableAgents, availableModels, modelListLoading, selectedAgent, onAgentChange, onConnectLocalRuntime, runtime, adapterReloadKey, threadFooterSlot, defaultSidebarWidth, sidebarWidth, position, defaultOpen, animateMobile, animateDesktop, chatViewTransition, chatViewTransitionHandoff, storageKey, openStorageKey, apiUrl, agentChatSurface, showTabBar, suppressInlineOpenApp, composerPlaceholder, openOnChatRunning, onFullscreenRequest, scope, showScopeBadge, browserTabId, threadUrlSync, agentPageHref, suppressFirstRunOnboarding, }: AgentSidebarProps): React.JSX.Element;
 /**
  * Focus the agent chat composer input.
  * Opens the sidebar if closed, then focuses the text input.