@sentry/junior 0.149.0 → 0.150.1

package/dist/chat/agent/tools.d.ts

@@ -25,7 +25,7 @@ import type { OAuthAuthorization } from "@/chat/oauth-authorization";
 import type { Actor } from "@/chat/actor";
 import type { AuthorizationPauseError } from "@/chat/services/auth-pause";
 import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
-import { type AgentRunDurability, type AgentRunObservers, type AgentRunPolicy, type AgentRunRouting, type AgentRunState } from "@/chat/agent/request";
+import { type AgentDurability, type AgentEvent, type AgentRun, type AgentRunState } from "@/chat/agent/types";
 import type { ResumeState } from "@/chat/agent/resume";
 interface ToolWiringArgs {
     abortAgent: () => void;
@@ -43,22 +43,19 @@ interface ToolWiringArgs {
     configurationValues: Record<string, unknown>;
     connectedMcpProviders: Set<string>;
     conversationPrivacy?: ConversationPrivacy;
-    durability: AgentRunDurability;
+    durability: AgentDurability;
     authorization?: OAuthAuthorization;
     generatedFiles: FileUpload[];
     invokedSkill: SkillMetadata | null;
-    observers: AgentRunObservers;
+    onEvent?: (event: AgentEvent) => void | Promise<void>;
     onFatalToolError(error: Error): void;
     onSandboxRefChanged: (sandboxRef: SandboxRef) => void;
-    policy: AgentRunPolicy;
     preAgentPromptMessages: () => PiMessage[];
     priorPiMessages: PiMessage[] | undefined;
     recordConnectedMcpProvider: (provider: string) => Promise<void>;
     requestHandoff?: ToolRuntimeContext["handoff"];
     resume: ResumeState;
-    routing: AgentRunRouting;
-    conversationId: string;
-    turnId: string;
+    run: AgentRun;
     skillSandbox: SkillSandbox;
     spanContext: LogContext;
     state: AgentRunState;

package/dist/chat/agent/{request.d.ts → types.d.ts}

@@ -1,11 +1,9 @@
 /**
- * Agent run request contract.
+ * Public agent-run launch contract.
  *
- * Groups the per-slice run request by the runtime role each field serves and
- * owns interpretation of the routing group: actor derivation, surface
- * inference, destination consistency checks, and session identifiers. Run
- * phases consume these groups directly; callers build them at runtime
- * boundaries.
+ * Providers build one flat `AgentRun` and call `AgentRunner.run`. Delivery and
+ * durability are capabilities that affect the run. `onEvent` is best-effort UI
+ * only. Stable composition binds stream, spawn, and tracing outside this type.
  */
 import type { Destination, ReplyAttribution, Source, SystemActor } from "@sentry/junior-plugin-api";
 import type { LocationConfigurationService } from "@/chat/configuration/types";
@@ -17,7 +15,6 @@ import type { SandboxRef } from "@/chat/sandbox/ref";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
 import type { OAuthAuthorization } from "@/chat/oauth-authorization";
-import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
@@ -27,26 +24,33 @@ import type { SlackActionToken } from "@/chat/slack/action-token";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 import type { ImageGenerateToolDeps, ViewImageToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
-export interface AgentRunAttachment {
+/** One attachment the model may see for the current instruction. */
+export type AgentAttachment = {
     data?: Buffer;
     mediaType: string;
     filename?: string;
     promptText?: string;
-}
-export interface AgentRunInstructionActor {
+};
+/** Instruction author metadata used for prompt labels and provenance. */
+export type AgentInstructionActor = {
     authorId?: string;
     authorName?: string;
+    /**
+     * Slack message ts for the instruction when known.
+     * TODO: generalize to a provider-neutral message id once prompt attrs are neutral.
+     */
     slackTs?: string;
-}
-export interface AgentRunSteeringMessage {
-    actor?: AgentRunInstructionActor;
+};
+/** One mid-turn steered user message drained from the durable mailbox. */
+export type AgentSteeringMessage = {
+    actor?: AgentInstructionActor;
     /** Provenance of this queued/steered message, carrying its original author. */
     provenance: ConversationMessageProvenance;
     omittedImageAttachmentCount?: number;
     text: string;
     timestampMs?: number;
-    userAttachments?: AgentRunAttachment[];
-}
+    attachments?: AgentAttachment[];
+};
 /** Model-safe input for one asynchronously delegated child-agent task. */
 export type SpawnAgentInput = {
     name?: string;
@@ -62,155 +66,160 @@ export type SpawnAgent = (input: SpawnAgentInput, options: {
     signal?: AbortSignal;
     toolCallId: string;
 }) => Promise<SpawnAgentResult>;
-/** Carries the user-visible content and prior transcript for one agent-run slice. */
-export interface AgentRunInput {
-    actor?: AgentRunInstructionActor;
-    includeConversationContextWithPiMessages?: boolean;
-    messageText: string;
-    userAttachments?: AgentRunAttachment[];
+/** Current user instruction for one agent-run slice. */
+export type AgentInstruction = {
+    text: string;
+    attachments?: readonly AgentAttachment[];
     inboundAttachmentCount?: number;
     omittedImageAttachmentCount?: number;
-    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
-    piMessages?: PiMessage[];
-    conversationContext?: string;
-}
-/**
- * Identity and addressing for one run.
- *
- * Set `actor` first (who runs). Derive `credentialContext` with
- * `credentialContextForActor(actor, subject?)` unless a caller already bound
- * credentials (dispatch with delegated subject). They name the same principal
- * except when a system actor carries `credentialContext.subject` for delegated
- * user tokens.
- */
-export interface AgentRunRouting {
-    /** Who this run executes as. Prefer always setting this. */
-    actor?: Actor;
-    /** Credential authority projected from actor (plus optional subject). */
-    credentialContext?: CredentialContext;
-    source: Source;
-    slackConversation?: SlackConversationContext;
+    /** Host-owned turn context shown to the model near the instruction. */
+    context?: string;
+    actor?: AgentInstructionActor;
     /**
-     * TODO: Move ephemeral Slack credentials into provider-owned turn context so
-     * the Slack tool registry can consume them without extending core routing.
+     * When history is present, still include `context` in the prompt. Default is
+     * to omit conversation context once durable history already carries it.
      */
-    slackActionToken?: SlackActionToken;
-    destination: Destination;
-    /** When true, also publish assistant output to the conversation destination. */
-    publishExternally?: boolean;
-    /** Confirmed visibility of the destination where this run is delivered. */
-    destinationVisibility?: ConversationPrivacy;
-    surface?: AgentTurnSurface;
-    dispatch?: {
-        actor?: SystemActor;
-        id: string;
-        metadata?: Record<string, string>;
-        plugin?: string;
-        replyAttribution?: ReplyAttribution;
-    };
-    toolChannelId?: string;
-}
+    includeConversationContextWithHistory?: boolean;
+};
+/** Dispatch identity carried on plugin-authored runs. */
+export type AgentDispatch = {
+    actor?: SystemActor;
+    id: string;
+    metadata?: Record<string, string>;
+    plugin?: string;
+    replyAttribution?: ReplyAttribution;
+};
 /** Optional agent capabilities that a run slice can turn off. */
 export declare const AGENT_RUN_FEATURES: readonly ["handoff", "interactive-auth", "subagents"];
-/** One optional agent capability controlled by run policy. */
-export type AgentRunFeature = (typeof AGENT_RUN_FEATURES)[number];
-/** Return whether one optional agent capability is disabled for this run. */
-export declare function isAgentRunFeatureDisabled(policy: Pick<AgentRunPolicy, "disabledFeatures"> | undefined, feature: AgentRunFeature): boolean;
-/** Carries execution limits and dependency overrides for one run slice. */
-export interface AgentRunPolicy {
-    /**
-     * Optional agent capabilities disabled for this run slice.
-     * `interactive-auth` blocks pausing to send an OAuth link; missing credentials
-     * hard-fail instead. Default is enabled when omitted.
-     * TODO(#881, #883): child invocations currently disable interactive-auth, but
-     * may later need a path to force the auth flow when a delegated tool requires
-     * credentials the parent can already request.
-     */
-    disabledFeatures?: readonly AgentRunFeature[];
-    /** Absolute wall-clock deadline for this host request, in milliseconds. */
-    turnDeadlineAtMs?: number;
-    /** Cancels provider work when the owning host request is abandoned. */
-    signal?: AbortSignal;
-    /** Explicit per-agent reasoning level. When set, adaptive routing is disabled. */
-    reasoningLevel?: TurnReasoningLevel;
-    configuration?: Record<string, unknown>;
-    locationConfiguration?: LocationConfigurationService;
-    skillDirs?: string[];
-    /** Per-slice override for app-owned sandbox egress trace propagation. */
-    sandboxTracePropagation?: SandboxEgressTracePropagationConfig;
-    /** Per-slice sandbox egress signal storage override. */
-    sandboxEgressSignals?: SandboxEgressSignalTransport;
-    toolOverrides?: {
-        imageGenerate?: ImageGenerateToolDeps;
-        viewImage?: ViewImageToolDeps;
-        webFetch?: WebFetchToolDeps;
-        webSearch?: WebSearchToolDeps;
-    };
-}
-/** Carries durable state snapshots already loaded by the caller. */
-export interface AgentRunState {
+/** One optional agent capability controlled per run. */
+export type AgentFeature = (typeof AGENT_RUN_FEATURES)[number];
+/** Already-loaded resume state for this conversation. */
+export type AgentRunState = {
     pendingAuth?: ConversationPendingAuthState;
     /** Persisted sandbox reuse state from prior slices of this conversation. */
     sandboxRef?: SandboxRef;
-}
-/**
- * Carries notification-only callbacks for streaming UI and status surfaces;
- * their failures never affect the run.
- */
-export interface AgentRunObservers {
-    onToolInvocation?: (invocation: {
-        params: Record<string, unknown>;
-        toolCallId: string;
-        toolName: string;
-    }) => void | Promise<void>;
-    onToolResult?: (result: ToolExecutionReport) => void | Promise<void>;
-    onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
-}
+};
 /**
  * Delivers completed tool-free assistant messages in model order.
  *
  * The runner must commit the preceding agent boundary before invoking this
  * port; the accepted reply transaction appends only this message.
  */
-export type AgentRunDelivery = (message: AssistantMessage) => void | Promise<void>;
+export type AgentDelivery = (message: AssistantMessage) => void | Promise<void>;
 /** Resume the agent turn after a transient or ambiguous delivery failure. */
 export declare class RetryableDeliveryError extends Error {
     constructor(cause: unknown);
 }
-/** Carries durable-worker ports that commit or update resumable run state. */
-export interface AgentRunDurability {
+/** Durable-worker ports that commit or update resumable run state. */
+export type AgentDurability = {
     /** Schedule delegated work with authority bound by the active parent run. */
     spawnAgent?: SpawnAgent;
     onInputCommitted?: () => void | Promise<void>;
     /** Return true when the durable worker should pause at the next Pi boundary. */
     shouldYield?: () => boolean;
-    drainSteeringMessages?: (accept: (messages: AgentRunSteeringMessage[]) => Promise<void>) => Promise<AgentRunSteeringMessage[]>;
+    drainSteeringMessages?: (accept: (messages: AgentSteeringMessage[]) => Promise<void>) => Promise<AgentSteeringMessage[]>;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState | undefined) => void | Promise<void>;
     onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
-}
-/** Groups the per-slice run request by the runtime role each field serves. */
-export interface AgentRunRequest {
+};
+/** Best-effort progress events. Failures here never affect the run. */
+export type AgentEvent = {
+    type: "status";
+    text: string;
+} | {
+    type: "tool_started";
+    toolCallId: string;
+    toolName: string;
+    params: Record<string, unknown>;
+} | {
+    type: "tool_finished";
+    report: ToolExecutionReport;
+};
+/** Resolved environment and optional per-run tool test overrides. */
+export type AgentEnvironment = {
+    configuration?: Record<string, unknown>;
+    locationConfiguration?: LocationConfigurationService;
+    skillDirs?: string[];
+    /** Per-slice override for app-owned sandbox egress trace propagation. */
+    sandboxTracePropagation?: SandboxEgressTracePropagationConfig;
+    /** Per-slice sandbox egress signal storage override. */
+    sandboxEgressSignals?: SandboxEgressSignalTransport;
+    toolOverrides?: {
+        imageGenerate?: ImageGenerateToolDeps;
+        viewImage?: ViewImageToolDeps;
+        webFetch?: WebFetchToolDeps;
+        webSearch?: WebSearchToolDeps;
+    };
+};
+/**
+ * One provider-launched agent-run slice.
+ *
+ * Build identity, instruction, history, delivery, and durability here. Bind
+ * stable model/stream composition when creating the runner, not on each run.
+ */
+export type AgentRun = {
     /** Durable conversation advanced by this run. */
     conversationId: string;
     /** Stable turn advanced across this run and any continuation runs. */
     turnId: string;
     /** Optional bounded-run identifier used only for observability. */
     runId?: string;
-    input: AgentRunInput;
-    routing: AgentRunRouting;
+    instruction: AgentInstruction;
+    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
+    history?: readonly PiMessage[];
+    /**
+     * Who this run executes as. Prefer always setting this. Derive
+     * `credentialContext` with `credentialContextForActor(actor, subject?)`
+     * unless a caller already bound credentials.
+     */
+    actor?: Actor;
+    /** Credential authority projected from actor (plus optional subject). */
+    credentialContext?: CredentialContext;
+    source: Source;
+    destination: Destination;
+    /** When true, also publish assistant output to the conversation destination. */
+    publishExternally?: boolean;
+    /** Confirmed visibility of the destination where this run is delivered. */
+    destinationVisibility?: ConversationPrivacy;
+    surface?: AgentTurnSurface;
+    dispatch?: AgentDispatch;
+    /**
+     * TODO: Move ephemeral Slack credentials and conversation labels into
+     * provider-owned tool/prompt context so the shared run edge stays neutral.
+     */
+    slackConversation?: SlackConversationContext;
+    slackActionToken?: SlackActionToken;
+    toolChannelId?: string;
     /** Surface-owned OAuth state and private delivery capabilities. */
     authorization?: OAuthAuthorization;
-    policy?: AgentRunPolicy;
+    /**
+     * Optional agent capabilities disabled for this run slice.
+     * `interactive-auth` blocks pausing to send an OAuth link; missing credentials
+     * hard-fail instead. Default is enabled when omitted.
+     * TODO(#881, #883): child invocations currently disable interactive-auth, but
+     * may later need a path to force the auth flow when a delegated tool requires
+     * credentials the parent can already request.
+     */
+    disabledFeatures?: readonly AgentFeature[];
+    /** Absolute wall-clock deadline for this host request, in milliseconds. */
+    deadlineAtMs?: number;
+    /** Cancels provider work when the owning host request is abandoned. */
+    signal?: AbortSignal;
+    /** Explicit per-agent reasoning level. When set, adaptive routing is disabled. */
+    reasoning?: TurnReasoningLevel;
+    environment?: AgentEnvironment;
     state?: AgentRunState;
-    observers?: AgentRunObservers;
-    delivery?: AgentRunDelivery;
-    durability?: AgentRunDurability;
-}
-/** Resolve the explicit actor or the system credential actor for this run. */
-export declare function actorFromRouting(routing: AgentRunRouting): Actor | undefined;
+    /** Best-effort progress only. */
+    onEvent?: (event: AgentEvent) => void | Promise<void>;
+    delivery?: AgentDelivery;
+    durability?: AgentDurability;
+};
+/** Return whether one optional agent capability is disabled for this run. */
+export declare function isAgentRunFeatureDisabled(disabledFeatures: readonly AgentFeature[] | undefined, feature: AgentFeature): boolean;
+/** Resolve the explicit actor, dispatch actor, or credential actor for this run. */
+export declare function actorFromRun(run: Pick<AgentRun, "actor" | "dispatch" | "credentialContext">): Actor | undefined;
 /** Reject contradictory provider coordinates before the run touches state. */
-export declare function assertRunRoutingConsistency(request: Pick<AgentRunRequest, "conversationId" | "routing">): void;
+export declare function assertRunConsistency(run: Pick<AgentRun, "conversationId" | "source" | "destination" | "surface" | "publishExternally" | "actor" | "dispatch">): void;
 /** Route tool side effects to the tool channel when one overrides the destination. */
-export declare function toolInvocationDestination(routing: AgentRunRouting): Destination;
+export declare function toolInvocationDestination(run: Pick<AgentRun, "destination" | "toolChannelId">): Destination;
 /** Infer the run surface when the caller did not state one. */
-export declare function surfaceFromRouting(routing: AgentRunRouting): AgentTurnSurface;
+export declare function surfaceFromRun(run: Pick<AgentRun, "surface" | "source">): AgentTurnSurface;

package/dist/chat/agent-dispatch/types.d.ts

@@ -1,6 +1,6 @@
 import type { DispatchOptions, DestinationVisibility, ReplyAttribution, Source, SlackDestination } from "@sentry/junior-plugin-api";
 import type { CredentialContext, CredentialSubject, CredentialSystemActor } from "@/chat/credentials/context";
-import type { AgentRunRouting } from "@/chat/agent/request";
+import type { AgentDispatch } from "@/chat/agent/types";
 import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import type { LocationConfigurationService } from "@/chat/configuration/types";
 export type DispatchStatus = "pending" | "running" | "awaiting_resume" | "completed" | "failed" | "blocked";
@@ -51,7 +51,7 @@ export interface DispatchTurnContext {
     locationConfiguration: LocationConfigurationService;
     credentialContext: CredentialContext;
     destinationVisibility: DestinationVisibility;
-    dispatch: NonNullable<AgentRunRouting["dispatch"]>;
+    dispatch: AgentDispatch;
     skipProviderDefaultConfig: true;
     source: Source;
     surface: Extract<AgentTurnSurface, "api">;

package/dist/chat/agent-invocations/spawn.d.ts

@@ -1,6 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
-import type { AgentRunRequest, SpawnAgent } from "@/chat/agent/request";
+import type { AgentRun, SpawnAgent } from "@/chat/agent/types";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 type SpawnOptions = {
     conversationStore?: ConversationStore;
@@ -8,5 +8,5 @@ type SpawnOptions = {
     state?: StateAdapter;
 };
 /** Bind one run's runtime-owned authority to the model-safe spawn capability. */
-export declare function bindSpawnAgent(request: AgentRunRequest, options: SpawnOptions): SpawnAgent | undefined;
+export declare function bindSpawnAgent(run: AgentRun, options: SpawnOptions): SpawnAgent | undefined;
 export {};

package/dist/chat/plugins/viewer.d.ts

@@ -4,6 +4,10 @@ import type { JuniorDatabase } from "@/db/db";
 export declare function resolveViewerUserFromSql(db: JuniorDatabase, email: string): Promise<User | undefined>;
 /** Resolve or create the canonical user for one authenticated viewer. */
 export declare function resolveViewerUser(email: string): Promise<User | undefined>;
+/** Update one canonical user's display name in SQL. */
+export declare function updateViewerDisplayNameFromSql(db: JuniorDatabase, userId: string, displayName: string): Promise<User | undefined>;
+/** Update one canonical user's display name. */
+export declare function updateViewerDisplayName(userId: string, displayName: string): Promise<User | undefined>;
 /** Resolve the stored identity and linked user for one runtime actor. */
 export declare function readActorIdentityFromSql(db: JuniorDatabase, actor: Actor): Promise<{
     identity: Identity;

package/dist/chat/runtime/agent-runner.d.ts

@@ -1,12 +1,14 @@
-import { type AgentRunRequest, type SpawnAgent } from "@/chat/agent/request";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { type AgentRun, type SpawnAgent } from "@/chat/agent/types";
 import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 /** Run one agent-run slice behind runtime-owned orchestration boundaries. */
 export interface AgentRunner {
-    run(request: AgentRunRequest): Promise<AgentRunOutcome>;
+    run(run: AgentRun): Promise<AgentRunOutcome>;
 }
-/** Adapt the Pi-facing agent-run executor behind the runtime-owned runner seam. */
-export declare function createAgentRunner(run: AgentRunner["run"], options?: {
-    bindSpawnAgent?: (request: AgentRunRequest) => SpawnAgent | undefined;
+/** Compose the agent executor with stable host dependencies. */
+export declare function createAgentRunner(execute: (run: AgentRun, streamFn?: StreamFn) => Promise<AgentRunOutcome>, options?: {
+    bindSpawnAgent?: (run: AgentRun) => SpawnAgent | undefined;
+    streamFn?: StreamFn;
     tracePropagation?: SandboxEgressTracePropagationConfig;
 }): AgentRunner;

package/dist/chat/runtime/slack-resume.d.ts

@@ -1,4 +1,4 @@
-import { type AgentRunRequest } from "@/chat/agent/request";
+import { type AgentRun } from "@/chat/agent/types";
 import type { AgentRunResult } from "@/chat/services/turn-result";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
@@ -44,8 +44,8 @@ interface ResumeSlackTurnArgs {
     beforeStart?: () => Promise<ResumePreparedTurn | false | void>;
     replyTimeoutMs?: number;
 }
-type ResumeReplyContext = Omit<AgentRunRequest, "conversationId" | "turnId" | "runId" | "input" | "delivery"> & {
-    input?: Omit<AgentRunRequest["input"], "messageText">;
+type ResumeReplyContext = Omit<AgentRun, "conversationId" | "turnId" | "runId" | "instruction" | "delivery"> & {
+    instruction?: Omit<AgentRun["instruction"], "text">;
 };
 interface ResumePreparedTurn {
     messageText: string;

package/dist/chat/task-execution/paused-turn.d.ts

@@ -1,13 +1,13 @@
 import { resumeSlackTurn } from "@/chat/runtime/slack-resume";
 import { type PausedTurnRequest } from "@/chat/task-execution/turn-wake";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
-import type { AgentRunRouting } from "@/chat/agent/request";
+import type { AgentRun } from "@/chat/agent/types";
 /** Runtime ports for paused turn scheduling. */
 export interface PausedTurnOptions {
     agentRunner: AgentRunner;
     /** Exact persisted input ids accepted while running the paused turn. */
     inputMessageIds?: readonly string[];
-    routingContext?: Pick<AgentRunRouting, "actor" | "credentialContext" | "destinationVisibility" | "dispatch" | "surface">;
+    routingContext?: Pick<AgentRun, "actor" | "credentialContext" | "destinationVisibility" | "dispatch" | "surface">;
     resumeTurn?: typeof resumeSlackTurn;
     wakePausedTurn?: (request: PausedTurnRequest) => Promise<void>;
     scheduleSessionCompletedPluginTasks?: (params: {

package/dist/chat/tools/types.d.ts

@@ -10,7 +10,7 @@ import type { WebActor, LocalActor, Actor, SlackActor } from "@/chat/actor";
 import type { SlackActionToken } from "@/chat/slack/action-token";
 import type { ModelProfile } from "@/chat/model-profile";
 import type { GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
-import type { SpawnAgent } from "@/chat/agent/request";
+import type { SpawnAgent } from "@/chat/agent/types";
 interface HandoffControl {
     /** Non-empty catalog of configured targets. */
     profiles: readonly [ModelProfile, ...ModelProfile[]];

package/dist/{chunk-EW2LNCRL.js → chunk-2AWDPNP7.js}

@@ -13,7 +13,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-3GYZ5YEH.js";
+} from "./chunk-GZ25ZSTX.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   sleep
@@ -23,14 +23,14 @@ import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-25SC7D6Z.js";
+} from "./chunk-B2YA2G26.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-32CXPIZE.js";
+} from "./chunk-FGP5W3NS.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -42,7 +42,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-RLVZIWNQ.js";
+} from "./chunk-3WIFZBJL.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";

package/dist/{chunk-X22XXSZA.js → chunk-2DIRU2C2.js}

@@ -1,6 +1,6 @@
 import {
   createPluginCatalogRuntime
-} from "./chunk-2JHKISQA.js";
+} from "./chunk-TZRYLW3R.js";
 
 // src/chat/plugins/catalog-runtime.ts
 var pluginCatalogRuntime = createPluginCatalogRuntime();

package/dist/{chunk-5CWUQXXT.js → chunk-2Z7YX5PI.js}

@@ -1,26 +1,26 @@
 import {
   appendAndEnqueueInboundMessage
-} from "./chunk-JMSMXXED.js";
+} from "./chunk-JVOLC6JZ.js";
 import {
   buildDeliveredTurnStatePatch,
   finalizeFailedTurnReplyWithEvent,
   getTurnUserMessage,
   processPluginTask,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-UZGASGOD.js";
+} from "./chunk-N6QJAPZS.js";
 import {
   ConversationTurnLifecycleService,
   coerceThreadConversationState,
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-4YKPOYRV.js";
+} from "./chunk-JBYWR6FW.js";
 import {
   healthReportSchema
 } from "./chunk-UTL3MHPC.js";
 import {
   parseSlackThreadId
-} from "./chunk-MEMURSBG.js";
+} from "./chunk-4JV7GUUH.js";
 import {
   TurnInputCommitLostError,
   buildConversationContext,
@@ -41,14 +41,14 @@ import {
   saveTurnCheckpoint,
   startActiveTurn,
   upsertConversationMessage
-} from "./chunk-EW2LNCRL.js";
+} from "./chunk-2AWDPNP7.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-SWHPVZBV.js";
+} from "./chunk-D2PVJU5E.js";
 import {
   getConversationEventStore,
   getConversationStore
-} from "./chunk-3GYZ5YEH.js";
+} from "./chunk-GZ25ZSTX.js";
 import {
   credentialContextForActor
 } from "./chunk-RUIXF3YQ.js";
@@ -56,7 +56,7 @@ import {
   logException,
   setTags,
   withLogContext
-} from "./chunk-RLVZIWNQ.js";
+} from "./chunk-3WIFZBJL.js";
 
 // src/handlers/health.ts
 function readHealthReport() {
@@ -522,24 +522,20 @@ function createApiTurnWorker(options) {
             conversationId: context.conversationId,
             turnId,
             runId: currentRunId,
-            input: {
-              messageText: text,
-              conversationContext: buildConversationContext(conversation, {
+            instruction: {
+              text,
+              context: buildConversationContext(conversation, {
                 excludeMessageId: userMessageId
-              }),
-              piMessages
-            },
-            routing: {
-              actor,
-              credentialContext: credentialContextForActor(actor),
-              destination,
-              publishExternally: false,
-              source,
-              surface: "api"
-            },
-            policy: {
-              disabledFeatures: ["interactive-auth"]
+              })
             },
+            history: piMessages,
+            actor,
+            credentialContext: credentialContextForActor(actor),
+            destination,
+            publishExternally: false,
+            source,
+            surface: "api",
+            disabledFeatures: ["interactive-auth"],
             state: {
               pendingAuth: conversation.processing.pendingAuth,
               sandboxRef

package/dist/{chunk-RLVZIWNQ.js → chunk-3WIFZBJL.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-6G5RCDKP.js";
+} from "./chunk-6IWDFUXW.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/{chunk-MEMURSBG.js → chunk-4JV7GUUH.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-F3B2YJ76.js";
 import {
   toOptionalString
-} from "./chunk-RLVZIWNQ.js";
+} from "./chunk-3WIFZBJL.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";