@gea-ai/agent-sdk 0.1.260924-alpha.0 → 0.1.260925-alpha.0

package/THIRD_PARTY_NOTICES.md

@@ -65,3 +65,24 @@ inventory ship in [third-party/agent-core](./third-party/agent-core/NOTICE).
 This includes Serde/serde_json, httpdate, jsonschema and its validation/regex/hash
 dependencies, plus build dependencies. The inventory records upstream repository
 license provenance where a crate distribution omitted its license file. The Agent CLI embeds this asset into the immutable Worker bundle.
+
+## Optional developer-prepared Python environment
+
+The Python preparation utility uses the developer-installed Pyodide (MPL-2.0),
+CPython and the developer-selected packages from that distribution's
+checksum-pinned package index. Its version is recorded in the generated lock.
+These bytes are not included in the SDK tarball or Worker Runtime image.
+When selected, NumPy, pandas and their dependency wheels remain
+intact, including their metadata and license files, in the developer's private
+bundle. Pyodide's glue is adapted by local environment-selection prefixes in
+`scripts/prepare-python.mjs`; the runner is `script-runtime/python.mjs`.
+
+Distribution/source references:
+
+- https://github.com/pyodide/pyodide
+- https://pyodide.org/en/stable/usage/downloading-and-deploying.html
+- https://github.com/numpy/numpy
+- https://github.com/pandas-dev/pandas
+
+Optional TypeScript transpilation uses Sucrase 3.35.1 (MIT), bundled into the private
+JavaScript/TypeScript child Worker by esbuild.

package/dist/agent-channel-author-runtime.d.ts

@@ -19,6 +19,19 @@ export declare function executeChannelBehavior(input: {
     environment: AgentChannelFetchEnvironment;
     signal: AbortSignal;
 }): Promise<{
+    sequence: number;
+    duplicate: boolean;
+} | {
+    state: AgentChannelJson;
+    intents: {
+        key: string;
+        payload: AgentChannelJson;
+        eventId: string;
+        operationId: string;
+    }[];
+    cursor: number;
+    idempotencyWindowMs?: number | undefined;
+} | {
     status: "sent";
     receipt?: AgentChannelJson | undefined;
 } | {
@@ -43,19 +56,6 @@ export declare function executeChannelBehavior(input: {
         message: string;
         retryable: boolean;
     };
-} | {
-    sequence: number;
-    duplicate: boolean;
-} | {
-    state: AgentChannelJson;
-    intents: {
-        key: string;
-        payload: AgentChannelJson;
-        eventId: string;
-        operationId: string;
-    }[];
-    cursor: number;
-    idempotencyWindowMs?: number | undefined;
 } | {
     events: {
         id: string;

package/dist/agent-channel-receiver.d.ts

@@ -1,4 +1,4 @@
-import type { DefinedAgentPackage } from "./index";
+import { type DefinedAgent } from "./index";
 import type { AgentChannelAddressStorage } from "./agent-channel-worker";
 import type { AgentChannelFetchEnvironment } from "./agent-worker";
 export type AgentChannelReceiverEnvironment = AgentChannelFetchEnvironment & {
@@ -27,7 +27,7 @@ export declare class AgentChannelReceiver {
     private definition?;
     private starting;
     constructor(storage: AgentChannelAddressStorage, environment: AgentChannelReceiverEnvironment, agents: Record<string, {
-        definition: DefinedAgentPackage;
+        definition: DefinedAgent;
     }>);
     private load;
     private persist;

package/dist/agent-channel-receiver.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { TaggedError } from "better-result";
 import { agentChannelReceiverControlSchema, agentChannelReceiverInitializationSchema, agentChannelReceiverStateSchema, agentChannelReceiverErrorSchema, } from "@gea-ai/contract/agent-channel-receivers";
+import { resolveAgentDefinition } from "./index.js";
 import { createChannelInputContext } from "./agent-channel-author-runtime.js";
 const recordSchema = z
     .object({
@@ -138,7 +139,10 @@ export class AgentChannelReceiver {
     async context(record, controller) {
         controller.signal.throwIfAborted();
         const initialized = agentChannelReceiverInitializationSchema.parse(await (await this.host(record.control, "initialize", {}, controller.signal)).json());
-        const definition = this.agents[record.control.agentKey]?.definition.channels.find((entry) => entry.provider === "custom" && entry.key === record.control.channelKey);
+        const agent = this.agents[record.control.agentKey]?.definition;
+        const definition = agent &&
+            resolveAgentDefinition(agent).channels.find((entry) => entry.provider === "custom" &&
+                entry.key === record.control.channelKey);
         if (!definition?.receiver)
             throw new Error("Channel receiver definition is unavailable.");
         this.definition = definition;

package/dist/agent-remote-run.d.ts

@@ -1,4 +1,6 @@
 import { Result } from "better-result";
+import { z } from "zod";
+import { agentApplicationAssistantMessageSchema } from "@gea-ai/contract/agent-applications";
 import type { AgentCallMessage, AgentChildRun, AgentChildRunDestination, AgentChildRunOutcome } from "@gea-ai/contract/agent-worker-tools";
 import type { StudioArtifactInputFile } from "@gea-ai/contract/studio-artifacts";
 /** Internal transport shared by hosted and local Run dispatch; not a public API client. */
@@ -26,5 +28,5 @@ export declare function submitRemoteRun(fetch: RemoteRunFetch, input: {
     sessionId: string;
 }, RemoteRunAdmissionError>>;
 export declare function cancelRemoteRun(fetch: RemoteRunFetch, run: AgentChildRun): Promise<void>;
-export declare function observeRemoteRun(fetch: RemoteRunFetch, run: AgentChildRun, signal: AbortSignal): Promise<AgentChildRunOutcome>;
+export declare function observeRemoteRun(fetch: RemoteRunFetch, run: AgentChildRun, signal: AbortSignal, onInputRequired?: (message: z.infer<typeof agentApplicationAssistantMessageSchema>) => Promise<void>): Promise<AgentChildRunOutcome>;
 export {};

package/dist/agent-remote-run.js

@@ -1,5 +1,6 @@
 import { Result, TaggedError } from "better-result";
 import { z } from "zod";
+import { agentApplicationAssistantMessageSchema, agentInputRequestKey, } from "@gea-ai/contract/agent-applications";
 import { agentHttpRunSchema, agentHttpMessageResourceSchema, } from "@gea-ai/contract/agent-http-api";
 const sessionSchema = z.object({ id: z.uuid() });
 const messagesSchema = z.object({
@@ -56,28 +57,45 @@ export async function cancelRemoteRun(fetch, run) {
     const response = await fetch(`/runs/${run.id}/cancel`, { method: "POST" });
     await responseJson(response);
 }
-export async function observeRemoteRun(fetch, run, signal) {
+export async function observeRemoteRun(fetch, run, signal, onInputRequired) {
+    let reportedInput;
     while (true) {
         signal.throwIfAborted();
         const record = agentHttpRunSchema.parse(await responseJson(await fetch(`/runs/${run.id}`, { signal })));
         if (record.id !== run.id || record.session_id !== run.sessionId)
             throw new Error("Remote Run identity mismatch.");
-        if (["finished", "error", "aborted", "interrupted"].includes(record.status)) {
+        const terminal = ["finished", "error", "aborted", "interrupted"].includes(record.status);
+        const inputMessageId = record.status === "waiting" ? record.input_message_id : null;
+        if (terminal || (onInputRequired && inputMessageId)) {
             const text = [];
             let cursor = null;
             do {
                 const page = messagesSchema.parse(await responseJson(await fetch(`/sessions/${run.sessionId}/messages?limit=100${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`, { signal })));
                 for (const message of page.items)
-                    if (message.run_id === run.id && message.role === "assistant")
+                    if (message.run_id === run.id && message.role === "assistant") {
+                        if (!terminal && message.id === inputMessageId && onInputRequired) {
+                            const input = agentApplicationAssistantMessageSchema.parse({
+                                id: message.id,
+                                role: message.role,
+                                parts: message.parts,
+                            });
+                            const key = agentInputRequestKey(input);
+                            if (key !== reportedInput) {
+                                await onInputRequired(input);
+                                reportedInput = key;
+                            }
+                        }
                         for (const part of message.parts)
                             if (part.type === "text" && typeof part.text === "string")
                                 text.push(part.text);
+                    }
                 cursor = page.next_cursor;
             } while (cursor);
-            return {
-                status: record.status,
-                text: text.join("\n").slice(0, 200_000),
-            };
+            if (terminal)
+                return {
+                    status: record.status,
+                    text: text.join("\n").slice(0, 200_000),
+                };
         }
         if (!["queued", "running", "waiting"].includes(record.status))
             throw new Error("Unknown remote Run status.");

package/dist/agent-run-host.js

@@ -226,7 +226,14 @@ export class AgentRunHost {
                 const fetch = (path, init) => this.host.remoteFetch(destination, path, init);
                 if (run.cancelRequested)
                     await cancelRemoteRun(fetch, run);
-                const outcome = await observeRemoteRun(fetch, run, cancellation.signal);
+                const outcome = await observeRemoteRun(fetch, run, cancellation.signal, async (message) => {
+                    const stored = await this.host.session("input", {
+                        runId: run.id,
+                        message,
+                    });
+                    if (!stored.ok)
+                        throw new Error(`Remote input notification rejected (${stored.status}).`);
+                });
                 const stored = await this.host.session("complete", {
                     runId: run.id,
                     ...outcome,

package/dist/agent-session-child-store.d.ts

@@ -72,6 +72,17 @@ export declare function getChildRun(tx: AgentSessionTransactionStorage, runId: s
         status: "aborted" | "error" | "finished" | "interrupted";
         text: string;
     } | null;
+    inputRequest?: {
+        id: string;
+        role: "assistant";
+        parts: {
+            [x: string]: unknown;
+            type: string;
+        }[];
+        metadata?: unknown;
+    } | undefined;
+    observedInputRequest?: string | undefined;
+    explicitWaitOnly?: boolean | undefined;
 } | undefined>;
 export declare function getChildSession(tx: AgentSessionTransactionStorage, sessionId: string): Promise<{
     agentKey: string;
@@ -149,6 +160,17 @@ export declare function readChildRuns(tx: AgentSessionTransactionStorage, refere
         status: "aborted" | "error" | "finished" | "interrupted";
         text: string;
     } | null;
+    inputRequest?: {
+        id: string;
+        role: "assistant";
+        parts: {
+            [x: string]: unknown;
+            type: string;
+        }[];
+        metadata?: unknown;
+    } | undefined;
+    observedInputRequest?: string | undefined;
+    explicitWaitOnly?: boolean | undefined;
 }[]>;
 export declare function listChildRuns(tx: AgentSessionTransactionStorage, after: number, limit: number): Promise<{
     runs: {
@@ -204,6 +226,17 @@ export declare function listChildRuns(tx: AgentSessionTransactionStorage, after:
             status: "aborted" | "error" | "finished" | "interrupted";
             text: string;
         } | null;
+        inputRequest?: {
+            id: string;
+            role: "assistant";
+            parts: {
+                [x: string]: unknown;
+                type: string;
+            }[];
+            metadata?: unknown;
+        } | undefined;
+        observedInputRequest?: string | undefined;
+        explicitWaitOnly?: boolean | undefined;
     }[];
     nextCursor: null;
     subagentConcurrencyVersion?: undefined;
@@ -262,6 +295,17 @@ export declare function listChildRuns(tx: AgentSessionTransactionStorage, after:
             status: "aborted" | "error" | "finished" | "interrupted";
             text: string;
         } | null;
+        inputRequest?: {
+            id: string;
+            role: "assistant";
+            parts: {
+                [x: string]: unknown;
+                type: string;
+            }[];
+            metadata?: unknown;
+        } | undefined;
+        observedInputRequest?: string | undefined;
+        explicitWaitOnly?: boolean | undefined;
     }[];
     nextCursor: number | null;
 }>;

package/dist/agent-session-children.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { agentApplicationAssistantMessageSchema } from "@gea-ai/contract/agent-applications";
 import { readTraceContext } from "./trace-context.js";
 import { traceContextSchema } from "@gea-ai/contract/traces";
 import { DEFAULT_MAX_CONCURRENT_SUBAGENTS, maxConcurrentSubagentsSchema, } from "@gea-ai/contract/agent-packages";
@@ -69,6 +70,20 @@ export async function handleAgentSessionChildren(request, storage) {
                 await acceptAgentSessionChildRun(tx, runId);
                 return Response.json({ accepted: true });
             }
+            case "input": {
+                const { runId, message } = runIdSchema
+                    .extend({ message: agentApplicationAssistantMessageSchema })
+                    .parse(value);
+                const run = await getChildRun(tx, runId);
+                if (!run)
+                    return Response.json({ error: "unknown_run" }, { status: 404 });
+                if (!run.outcome) {
+                    run.inputRequest = message;
+                    await putChildRun(tx, run);
+                    await scheduleAgentSessionChildRunChanges(tx);
+                }
+                return Response.json({ run });
+            }
             case "start":
             case "reserve": {
                 const input = startSchema.parse(value);

package/dist/agent-session-inbox.js

@@ -1,7 +1,7 @@
 import { getChildRun, putChildRun, readChildRuns, readChildRunIndex, } from "./agent-session-child-store.js";
 import { z } from "zod";
 import { agentSessionExecutionTurnSchema } from "@gea-ai/contract/agent-session";
-import { agentApplicationAssistantMessageSchema } from "@gea-ai/contract/agent-applications";
+import { agentApplicationAssistantMessageSchema, agentInputRequestKey, } from "@gea-ai/contract/agent-applications";
 import { canonicalAgentChannelJson } from "@gea-ai/contract/agent-channels";
 import { agentSessionIdentitySchema, agentSessionBootstrapSchema, agentSessionTransportSchema, agentSessionDispatchSchema, agentSessionInboxFinishSchema, agentSessionInboxExecutionSchema, agentSessionSendSchema, agentRunWaitInputSchema, agentRunWaitResultSchema, toAgentRunWaitOutput, } from "@gea-ai/contract/agent-session-inbox";
 import { combineTraceContexts, readTraceContext } from "./trace-context.js";
@@ -40,6 +40,14 @@ const stateSchema = z.strictObject({
     terminal: terminalSchema.nullable().default(null),
     draining: terminalSchema.nullable().default(null),
     terminalQueue: z.array(terminalSchema).max(8).default([]),
+    inputNotification: z
+        .strictObject({
+        execution: agentSessionInboxExecutionSchema,
+        transport: agentSessionTransportSchema,
+        message: agentApplicationAssistantMessageSchema,
+    })
+        .nullable()
+        .default(null),
 });
 /** Only private definitions/self copies share the owning Agent's business context. */
 export async function inheritedAgentSessionMetadata(tx, destination) {
@@ -101,6 +109,7 @@ async function skipInputWait(tx, state, runs) {
         transport: state.transport,
     };
     state.inputWait = null;
+    state.inputNotification = null;
     if (runs.some((run) => !run.outcome)) {
         state.stopped = true;
         for (const run of runs)
@@ -280,17 +289,33 @@ function waitResult(state, runs, cancelled = false) {
             ? "steering"
             : !pendingRunIds.length
                 ? "completed"
-                : state.wait.deadline !== null && state.wait.deadline <= Date.now()
-                    ? "timeout"
-                    : null;
+                : selected.some((run) => !run.outcome &&
+                    run.inputRequest &&
+                    agentInputRequestKey(run.inputRequest) !==
+                        run.observedInputRequest)
+                    ? "input_required"
+                    : state.wait.deadline !== null && state.wait.deadline <= Date.now()
+                        ? "timeout"
+                        : null;
     return reason
         ? {
             toolCallId: state.wait.toolCallId ?? "join",
             reason,
             runs: selected
-                .filter((run) => run.outcome !== null)
+                .filter((run) => run.outcome !== null ||
+                (reason === "input_required" && run.inputRequest))
                 .map((run) => {
                 const limit = Math.floor(170_000 / Math.max(1, selected.length) / 6);
+                if (!run.outcome)
+                    return {
+                        runId: run.id,
+                        sessionId: run.sessionId,
+                        status: "waiting",
+                        text: "This Run needs external tool input. Reply through its Session API, then explicitly call runWait again to await its completion.",
+                        input: z
+                            .json()
+                            .parse(JSON.parse(JSON.stringify(run.inputRequest))),
+                    };
                 return {
                     runId: run.id,
                     sessionId: run.sessionId,
@@ -305,6 +330,20 @@ function waitResult(state, runs, cancelled = false) {
         }
         : null;
 }
+/** Returning input transfers further waiting to the caller, including the other selected Runs. */
+async function consumeInputRequest(tx, state, runs, result) {
+    if (result?.reason !== "input_required" || !state.wait)
+        return;
+    for (const run of runs)
+        if (state.wait.runIds.includes(run.id)) {
+            run.explicitWaitOnly = true;
+            if (run.inputRequest)
+                run.observedInputRequest = agentInputRequestKey(run.inputRequest);
+            if (run.destination.type === "remote")
+                state.pendingStarts = state.pendingStarts.filter((id) => id !== run.id);
+            await putChildRun(tx, run);
+        }
+}
 /** State and the single wake deadline always commit in the same storage transaction. */
 async function save(tx, state, runs) {
     // Completion bursts spill to individual records; only a bounded batch joins the inbox.
@@ -320,7 +359,8 @@ async function save(tx, state, runs) {
             await tx.delete(key);
         }
     }
-    if (state.draining && !runs.some((run) => !run.outcome)) {
+    if (state.draining &&
+        !runs.some((run) => !run.outcome && (!run.explicitWaitOnly || state.stopped))) {
         if (state.terminal)
             state.terminalQueue.push(state.draining);
         else
@@ -349,7 +389,10 @@ async function save(tx, state, runs) {
     const leaseDeadline = turn?.runId === state.execution?.turnId && turn?.status === "running"
         ? Date.parse(turn.leaseExpiresAt)
         : null;
-    const scheduled = cancelling || state.pendingStarts.length || state.terminal
+    const scheduled = cancelling ||
+        state.pendingStarts.length ||
+        state.terminal ||
+        state.inputNotification
         ? Date.now()
         : state.execution
             ? state.started || !state.transport
@@ -384,7 +427,7 @@ export async function notifyAgentSessionChildRun(tx, run) {
         await save(tx, state, runs);
         return;
     }
-    if (!state.wait?.runIds.includes(run.id)) {
+    if (!state.wait?.runIds.includes(run.id) && !run.explicitWaitOnly) {
         const id = `run:${run.id}`;
         if (!(await tx.get(`inbox:message:${id}`))) {
             const message = agentSessionSendSchema.parse({
@@ -425,11 +468,18 @@ async function finishInbox(tx, state, runs, input) {
             return Response.json({ error: "execution_not_expired" }, { status: 409 });
         }
     }
-    if (inputWait && !outcome && !state.stopped)
+    if (inputWait && !outcome && !state.stopped) {
         state.inputWait = {
             turnId: state.execution.turnId,
             messageId: inputWait.messageId,
         };
+        if (inputWait.message && state.transport)
+            state.inputNotification = {
+                execution: { ...state.execution, messages: [], waitResult: null },
+                transport: state.transport,
+                message: inputWait.message,
+            };
+    }
     // A transport disconnect does not revoke already accepted child runs.
     if (outcome?.status === "cancelled" &&
         !state.stopped &&
@@ -464,7 +514,7 @@ async function finishInbox(tx, state, runs, input) {
             },
             transport: state.transport,
         };
-        if (runs.some((run) => !run.outcome))
+        if (runs.some((run) => !run.outcome && (!run.explicitWaitOnly || state.stopped)))
             state.draining = terminal;
         else if (state.terminal)
             state.terminalQueue.push(terminal);
@@ -530,6 +580,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                 execution: null,
                 wait: null,
                 inputWait: null,
+                inputNotification: null,
                 alarmAt: null,
                 transport: null,
                 started: false,
@@ -628,6 +679,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                 };
                 state.wait = null;
                 state.inputWait = null;
+                state.inputNotification = null;
                 state.resumeWait = null;
                 if (!state.draining)
                     state.stopped = false;
@@ -654,6 +706,14 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                 const input = agentSessionDispatchSchema.parse(body);
                 if (input.cancelRunIds || input.startRunIds)
                     return Response.json({ accepted: true });
+                if (input.inputRequired) {
+                    if (input.execution.id === state.inputNotification?.execution.id &&
+                        input.inputRequired.id === state.inputNotification.message.id) {
+                        state.inputNotification = null;
+                        await save(tx, state, runs);
+                    }
+                    return Response.json({ accepted: true });
+                }
                 if (input.outcome &&
                     input.execution.id === state.terminal?.execution.id) {
                     state.terminal = state.terminalQueue.shift() ?? null;
@@ -717,6 +777,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     return Response.json({ execution: null });
                 const messages = takeMessages(state, state.wait !== null);
                 const joining = state.wait?.toolCallId === null;
+                await consumeInputRequest(tx, state, runs, result);
                 state.stopped = false;
                 state.execution = {
                     id: crypto.randomUUID(),
@@ -768,6 +829,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     state.wait?.turnId ??
                     state.execution?.turnId;
                 state.inputWait = null;
+                state.inputNotification = null;
                 state.wait = null;
                 if (state.execution && !state.started) {
                     state.resumeWait ??= state.execution.waitResult;
@@ -816,7 +878,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     return Response.json({ error: "execution_cancelled" }, { status: 409 });
                 if (path.endsWith("/join")) {
                     const runIds = runs
-                        .filter((run) => !run.outcome ||
+                        .filter((run) => (!run.outcome && !run.explicitWaitOnly) ||
                         state.messages.some((entry) => entry.id === `run:${run.id}`))
                         .map((run) => run.id)
                         .slice(0, 128);
@@ -859,11 +921,19 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                             : Date.now() + input.timeoutMs,
                         traceContext: readTraceContext(request.headers),
                     };
+                    // A remote observation may have stopped after returning input to the caller.
+                    for (const run of runs)
+                        if (input.runIds.includes(run.id) &&
+                            run.destination.type === "remote" &&
+                            !run.outcome &&
+                            !state.pendingStarts.includes(run.id))
+                            state.pendingStarts.push(run.id);
                     for (const id of input.runIds)
                         await tx.delete(`inbox:child-result:${id}`);
                     // A completed result already queued as a notification is consumed by this wait.
                     state.messages = state.messages.filter((entry) => !input.runIds.some((id) => entry.id === `run:${id}`));
                     const result = waitResult(state, runs);
+                    await consumeInputRequest(tx, state, runs, result);
                     if (result)
                         state.wait = null;
                     await save(tx, state, runs);
@@ -932,9 +1002,14 @@ export async function handleAgentSessionAlarm(storage, environment) {
         .filter((run) => !run.outcome && run.cancelRequested)
         .map((run) => run.id);
     const childCommands = cancelling.length > 0 || state.pendingStarts.length > 0;
-    if (state.started && !childCommands && !state.terminal)
+    if (state.started &&
+        !childCommands &&
+        !state.terminal &&
+        !state.inputNotification)
         return;
-    let execution = state.terminal?.execution ?? state.execution;
+    let execution = state.terminal?.execution ??
+        state.inputNotification?.execution ??
+        state.execution;
     if (childCommands && !execution)
         execution = {
             id: crypto.randomUUID(),
@@ -959,9 +1034,10 @@ export async function handleAgentSessionAlarm(storage, environment) {
         const current = await readState(tx);
         if (!current ||
             (!childCommands &&
-                ((current.terminal?.execution.id ?? current.execution?.id) !==
-                    executionId ||
-                    (current.started && !current.terminal))))
+                ((current.terminal?.execution.id ??
+                    current.inputNotification?.execution.id ??
+                    current.execution?.id) !== executionId ||
+                    (current.started && !current.terminal && !current.inputNotification))))
             return false;
         current.alarmAt = Date.now() + 30_000;
         await tx.setAlarm(current.alarmAt);
@@ -972,7 +1048,9 @@ export async function handleAgentSessionAlarm(storage, environment) {
         return;
     const transport = !childCommands && state.terminal
         ? state.terminal.transport
-        : state.transport;
+        : !childCommands && state.inputNotification
+            ? state.inputNotification.transport
+            : state.transport;
     const target = environment[transport.namespace];
     const response = await target.get(target.idFromName(transport.name)).fetch(new Request("https://agent-session.internal/v1/inbox/dispatch", {
         method: "POST",
@@ -987,7 +1065,9 @@ export async function handleAgentSessionAlarm(storage, environment) {
                     ? { startRunIds: state.pendingStarts }
                     : state.terminal
                         ? { outcome: state.terminal.outcome }
-                        : {}),
+                        : state.inputNotification
+                            ? { inputRequired: state.inputNotification.message }
+                            : {}),
         }),
     }));
     if (!response.ok)

package/dist/agent-session-runner.d.ts

@@ -14,12 +14,13 @@ export declare class AgentSessionRunner {
     join(): Promise<void>;
     private request;
     wait(input: z.infer<typeof agentRunWaitInputSchema>, toolCallId: string): Promise<{
-        reason: "cancelled" | "completed" | "steering" | "timeout";
+        reason: "cancelled" | "completed" | "input_required" | "steering" | "timeout";
         runs: {
-            status: "aborted" | "error" | "finished" | "interrupted";
             text: string;
+            status: "aborted" | "error" | "finished" | "interrupted" | "waiting";
             runId: string;
             sessionId: string;
+            input?: z.util.JSONType | undefined;
             textTruncated?: boolean | undefined;
         }[];
         pendingRunIds: string[];

package/dist/agent-worker.d.ts

@@ -17,7 +17,7 @@ import { type AgentExecutionEnvironment, type AgentPackageSnapshot, type AgentRu
 import { z } from "zod";
 export { AgentChannelReceiver } from "./agent-channel-receiver";
 import { type AgentChannelJournalAppend } from "@gea-ai/contract/agent-channel-runtime";
-import { type AgentDurableObjectNamespace, type AgentToolApprovalDecision, type AgentToolIdentity, type AgentToolRuntimeSdk, type DefinedAgentPackage } from "./index";
+import { type AgentDurableObjectNamespace, type AgentToolApprovalDecision, type AgentToolIdentity, type AgentToolRuntimeSdk, type DefinedAgent } from "./index";
 import { type AgentChannelAddressEnvironment } from "./agent-channel-worker";
 export { handleAgentChannelAddressAlarm, handleAgentChannelAddressRequest, type AgentChannelAddressEnvironment, type AgentChannelAddressStorage, type AgentChannelAddressTransactionStorage, } from "./agent-channel-worker";
 export type AgentHostBinding = Partial<WorkerAI> & {
@@ -76,7 +76,6 @@ export type AgentWorkerComputerOptions = {
     signal?: AbortSignal;
 };
 export type AgentFetchEnvironment = Record<string, unknown> & {
-    PROJECT?: import("@gea-ai/contract").WorkerProjectBinding;
     AGENT_SESSIONS: AgentSessionNamespace;
     AGENT_TASK_SESSIONS?: AgentSessionNamespace;
     AGENTS?: AgentHostBinding;
@@ -96,8 +95,8 @@ export type AgentChannelFetchEnvironment = AgentFetchEnvironment & AgentChannelA
     CHANNEL_SESSIONS: AgentSessionNamespace;
     CHANNEL_RECEIVERS?: AgentChannelAddressNamespace;
 };
-type AgentApplicationDefinition = {
-    definition: DefinedAgentPackage;
+export type AgentApplicationDefinition = {
+    definition: DefinedAgent;
     instructions?: string;
     skillMount?: AgentWorkerSkillMount;
     subagents?: Record<string, AgentApplicationDefinition>;
@@ -107,13 +106,6 @@ type AgentStartupTiming = {
     phases: Record<string, number>;
 };
 export declare function composeFetch<TEnvironment, TContext>(...handlers: ReadonlyArray<ComposableFetch<TEnvironment, TContext>>): (request: Request, environment: TEnvironment, context: TContext) => Promise<Response>;
-export declare function createAgentFetch<TEnvironment extends AgentFetchEnvironment = AgentFetchEnvironment, TContext = unknown>(definition: DefinedAgentPackage): ComposableFetch<TEnvironment, TContext>;
-/**
- * Creates the public SDK-first Agent application protocol. A root agent.ts is
- * addressed by /gea/agents/run; top-level agents/<key>/agent.ts entrypoints are
- * addressed by /gea/agents/<key>/run. All main Agents share the Worker
- * deployment lifecycle while keeping separate AgentSession namespaces.
- */
 export declare function createAgentApplicationFetch<TEnvironment extends AgentFetchEnvironment = AgentFetchEnvironment, TContext = unknown>(input: {
     agents: Record<string, AgentApplicationDefinition>;
     defaultAgentKey: string;