@gea-ai/agent-sdk 0.1.261019-alpha.1 → 0.1.261021-alpha.0

package/dist/agent-channel-author-runtime.js

@@ -23,6 +23,7 @@ const sessionSchema = z
 })
     .nullable();
 const receiptSchema = z.object({
+    queued: z.boolean().default(false),
     runId: z.uuid(),
     inputId: z.string().min(1),
     conversationId: z.string(),

package/dist/agent-channel-runtime.js

@@ -231,6 +231,7 @@ export async function handleCustomChannelAddressRequest(request, storage, enviro
         });
         return json({
             conversationId: config.address.providerLocalKey,
+            queued: receipt.queued,
             duplicate: receipt.duplicate,
             executionTarget: receipt.executionTarget,
             operationId: operation.input.operationId,

package/dist/agent-computer-session.js

@@ -244,7 +244,9 @@ export async function createAgentComputerSession(input) {
             }
             : { processRequest: undefined }),
         exec: async (id, value, opts) => {
-            if (protocol) {
+            // A cancelled HTTP exec response cannot confirm process termination.
+            // Process-capable compatibility providers use the same owned kill/close path.
+            if (computer.processRequest) {
                 const signal = AbortSignal.any([
                     opts?.signal ?? input.signal,
                     lifetime.signal,
@@ -253,6 +255,7 @@ export async function createAgentComputerSession(input) {
                 const result = z.object({ processId: z.string() }).parse(await computer.processRequest(id, "process-start", {
                     ...value,
                     cwd: value.cwd ?? opened.roots.workspace,
+                    stdin: false,
                     timeoutMs: 120_000,
                 }, { ...opts, signal }));
                 return createComputerProcess({

package/dist/agent-session-execution.js

@@ -29,34 +29,17 @@ export class SessionProtocolError extends Error {
         this.status = status;
     }
 }
-/**
- * Inbox continuation and failure takeover share one execution budget.
- * A stored user-input wait (ask_user / approval) keeps its attempt.
+/** Waiting continues the same work; only an expired running takeover spends
+ * another failure attempt. Every admission still receives a fresh attemptId.
+ * Keep old persisted counts conservatively: they may include genuine failures.
  */
-function admitExecutionAttempt(active, preserveAttempt = false) {
-    if (preserveAttempt) {
-        if (!active)
-            throw new SessionProtocolError("takeover_mismatch");
+function admitExecutionAttempt(active) {
+    if (active?.status === "waiting")
         return active.attempt;
-    }
     if (active && active.attempt >= MAX_AGENT_SESSION_EXECUTION_ATTEMPTS)
         throw new SessionProtocolError("attempts_exhausted");
     return (active?.attempt ?? 0) + 1;
 }
-async function resumesUserInput(tx, active) {
-    if (active?.status !== "waiting")
-        return false;
-    const state = await getAgentSessionRunState(tx, active.runId);
-    if (state?.status === "waiting" &&
-        "inputMessageId" in state &&
-        Boolean(state.inputMessageId))
-        return true;
-    // App Server enter clears inputWait before reserve admits the attempt.
-    // The continuation was already validated against that wait.
-    return (state?.status === "running" &&
-        "userInputResumeMessageId" in state &&
-        Boolean(state.userInputResumeMessageId));
-}
 function json(value, status = 200) {
     return Response.json(value, {
         status,
@@ -314,7 +297,7 @@ export async function startAgentSessionInvocation(tx, input) {
         activeStreamId: null,
         cancelRequestedAt: active?.cancelRequestedAt ?? null,
         ...selection,
-        attempt: admitExecutionAttempt(active, await resumesUserInput(tx, active)),
+        attempt: admitExecutionAttempt(active),
         attemptId: crypto.randomUUID(),
         leaseExpiresAt: new Date(Date.now() + AGENT_SESSION_EXECUTION_LEASE_MS).toISOString(),
         leaseOwner: "host",
@@ -743,7 +726,7 @@ export async function handleAgentSessionExecutionRequest(request, storage) {
                     activeStreamId: null,
                     cancelRequestedAt: active?.cancelRequestedAt ?? null,
                     ...selection,
-                    attempt: admitExecutionAttempt(active, await resumesUserInput(tx, active)),
+                    attempt: admitExecutionAttempt(active),
                     attemptId: crypto.randomUUID(),
                     leaseExpiresAt: new Date(Date.now() + AGENT_SESSION_EXECUTION_LEASE_MS).toISOString(),
                     leaseOwner: "host",

package/dist/agent-session-inbox.js

@@ -1185,6 +1185,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     return Response.json({ error: "input_not_found" }, { status: 404 });
                 const accepted = agentSessionEnqueueSchema.parse(stored);
                 return Response.json(agentSessionEnqueueReceiptSchema.parse({
+                    ...(await tx.get(`inbox:admission:${id}`)),
                     id,
                     runId: accepted.runId,
                     executionTarget: accepted.executionTarget,
@@ -1212,6 +1213,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                         canonicalAgentChannelJson(input))
                         return Response.json({ error: "message_identity_conflict" }, { status: 409 });
                     return Response.json(agentSessionEnqueueReceiptSchema.parse({
+                        ...(await tx.get(`inbox:admission:${accepted.message.id}`)),
                         id: accepted.message.id,
                         runId: accepted.runId,
                         executionTarget: accepted.executionTarget,
@@ -1227,8 +1229,37 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     (await tx.get(`inbox:message:${input.message.id}`)) !== undefined)
                     return Response.json({ error: "message_identity_conflict" }, { status: 409 });
                 if (state.messages.length >= 128 ||
-                    new TextEncoder().encode(JSON.stringify(state) + JSON.stringify(input)).byteLength > 2_000_000)
-                    return Response.json({ error: "inbox_full" }, { status: 429 });
+                    new TextEncoder().encode(JSON.stringify(state) + JSON.stringify(input)).byteLength > 2_000_000) {
+                    if (!input.channel)
+                        return Response.json({ error: "inbox_full" }, { status: 429 });
+                    // Freeze Channel rejection before any ACK/feedback. Replays must never
+                    // become accepted after capacity frees, even if this response is lost.
+                    // A first input can exceed the byte bound before an inbox exists.
+                    await writeState(tx, state);
+                    await putSessionPayload(tx, key, input);
+                    await tx.put(`inbox:admission:${input.message.id}`, {
+                        queued: false,
+                        rejected: true,
+                    });
+                    return Response.json(agentSessionEnqueueReceiptSchema.parse({
+                        id: input.message.id,
+                        runId: input.runId,
+                        executionTarget: input.executionTarget,
+                        duplicate: false,
+                        queued: false,
+                        rejected: true,
+                    }));
+                }
+                const requiresQueue = Boolean(state.messages.length ||
+                    state.execution ||
+                    state.wait ||
+                    state.inputWait ||
+                    state.draining ||
+                    state.terminal ||
+                    state.queuePaused);
+                await tx.put(`inbox:admission:${input.message.id}`, {
+                    queued: requiresQueue,
+                });
                 const message = {
                     ...input.message,
                     runId: input.runId,
@@ -1240,6 +1271,7 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                 await tx.put(`inbox:enqueue-run:${input.runId}`, message.id);
                 await save(tx, state, runs);
                 return Response.json(agentSessionEnqueueReceiptSchema.parse({
+                    queued: requiresQueue,
                     id: message.id,
                     runId: input.runId,
                     executionTarget: input.executionTarget,
@@ -1315,6 +1347,31 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                         executionTarget: agentSessionRunTargetSchema.parse(target),
                     });
             }
+            case "settled": {
+                z.strictObject({}).parse(body);
+                if (!state.appServer)
+                    return Response.json({ error: "execution_unconfirmed" }, { status: 409 });
+                const children = await readChildRunIndex(tx);
+                // Inspect the complete owner state, not the filtered public snapshot.
+                const unfinished = state.execution ||
+                    state.wait ||
+                    state.inputWait ||
+                    state.messages.length ||
+                    state.pendingStarts.length ||
+                    state.terminal ||
+                    state.draining ||
+                    state.terminalQueue.length ||
+                    state.inputNotification ||
+                    runs.some((run) => !run.outcome) ||
+                    children?.reservations.length ||
+                    (await activeComputerOperation(tx)) ||
+                    (await tx.get("execution-v2:active-turn")) ||
+                    (await tx.get("active-turn")) ||
+                    (await tx.list({ prefix: "inbox:terminal:", limit: 1 })).size;
+                return unfinished
+                    ? Response.json({ error: "execution_unfinished" }, { status: 409 })
+                    : Response.json({ settled: true });
+            }
             case "snapshot": {
                 if (!state.appServer)
                     return Response.json({ error: "legacy_session_read_only" }, { status: 409 });

package/dist/agent-worker.js

@@ -1,3 +1,4 @@
+import { recordModelRequest, recordModelSkills } from "./model-diagnostics.js";
 import { agentModelTerminationSchema, } from "@gea-ai/contract/agent-usage";
 export { uploadChannelInput } from "./agent-channel-api.js";
 import { createChannelSessionNamespace } from "./agent-channel-session-transport.js";
@@ -3406,6 +3407,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         }
         input = { ...input, bindings: { ...scopedBindings, computer } };
     }
+    await recordModelSkills(input.skillMount?.files ?? []);
     const skillTool = createAgentSkillTool({
         files: input.skillMount?.files ?? [],
         mountedRoot: mountedSkillRoot,
@@ -4291,8 +4293,14 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     let failure;
     const executionErrorText = (error, fallback = "Agent execution failed.") => {
         const original = failure?.error ?? error;
-        return original instanceof AgentMediaReadError
-            ? original.message
+        if (original instanceof AgentMediaReadError)
+            return original.message;
+        // Copy only the opaque Host correlation ID across the masked UI boundary.
+        const diagnosticId = original instanceof Error
+            ? /Diagnostic ID: ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i.exec(original.message)?.[1]
+            : undefined;
+        return diagnosticId
+            ? `${fallback} Diagnostic ID: ${diagnosticId}`
             : fallback;
     };
     let executionDiagnostics;
@@ -4778,6 +4786,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             onError: engine.onError,
             async fetch(request, init) {
                 const startedAt = performance.now();
+                await recordModelRequest(init?.body, coreConnection.provider.format, modelSpan);
                 const response = await coreConnection.fetch(request, init);
                 modelSpan?.setAttributes({
                     "gea.model.protocol": coreConnection.provider.format,

package/dist/catalog-language-model.js

@@ -1,3 +1,4 @@
+import { recordModelRequest } from "./model-diagnostics.js";
 import { moveOpenAICompatibleCacheControlToMessageContent } from "./openai-compatible-cache-control.js";
 export { moveOpenAICompatibleCacheControlToMessageContent } from "./openai-compatible-cache-control.js";
 import { createAnthropic } from "@ai-sdk/anthropic";
@@ -125,6 +126,7 @@ export function createCatalogLanguageModel(config) {
         headers.delete("authorization");
         headers.delete("x-api-key");
         headers.set(config.auth === "bearer" ? "authorization" : "x-api-key", config.auth === "bearer" ? `Bearer ${config.apiKey}` : config.apiKey);
+        await recordModelRequest(body, config.format);
         return config.fetch(input, {
             ...init,
             headers,

package/dist/channels/index.d.ts

@@ -21,6 +21,7 @@ declare const ChannelInputError_base: import("better-result").TaggedErrorClass<"
 export declare class ChannelInputError extends ChannelInputError_base {
 }
 export type ChannelSendReceipt = {
+    queued: boolean;
     runId: string;
     inputId: string;
     conversationId: string;

package/dist/evals-core.js

@@ -1,3 +1,4 @@
+import { recordModelRequest } from "./model-diagnostics.js";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { AgentCoreError, createAgentCore, runAgentCore, } from "./experimental/agent-core.js";
 import { fromModelMessages, toModelMessages, } from "./experimental/agent-core-messages.js";
@@ -40,7 +41,10 @@ export async function runJudgeCore(input) {
     });
     const turn = runAgentCore(core, { type: "start" }, {
         ...tools,
-        fetch: connection.fetch,
+        async fetch(request, init) {
+            await recordModelRequest(init?.body, connection.provider.format, modelSpan);
+            return connection.fetch(request, init);
+        },
         async prepareStep(value) {
             step = value.step;
             input.onStep(step);

package/dist/model-diagnostics.d.ts

@@ -0,0 +1,14 @@
+import { type Span } from "@opentelemetry/api";
+export declare const modelDiagnosticContext: symbol;
+export type ModelDiagnosticContext = {
+    skillsSha256?: string;
+};
+/** Sort object keys recursively; preserve array order (including anyOf/ref lists). */
+export declare function canonicalHash(value: unknown): Promise<string>;
+export declare function recordModelSkills(files: ReadonlyArray<{
+    path: string;
+    dataBase64: string;
+}>): Promise<void>;
+/** Called after codec/default merging, immediately before transport. Never retain
+ * headers, endpoints, user messages, schema text, or arbitrary provider options. */
+export declare function recordModelRequest(body: unknown, format: string, span?: Span | undefined): Promise<void>;

package/dist/model-diagnostics.js

@@ -0,0 +1,117 @@
+import { context, createContextKey, trace, } from "@opentelemetry/api";
+import { z } from "zod";
+export const modelDiagnosticContext = createContextKey("gea model diagnostics");
+/** Sort object keys recursively; preserve array order (including anyOf/ref lists). */
+export async function canonicalHash(value) {
+    const serialized = JSON.stringify(value, (_key, entry) => {
+        if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
+            return Object.fromEntries(Object.entries(entry).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+        }
+        return entry;
+    });
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(serialized));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export async function recordModelSkills(files) {
+    const scope = context.active().getValue(modelDiagnosticContext);
+    if (scope)
+        scope.skillsSha256 = await canonicalHash([...files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+const wireTool = z.object({
+    type: z.string().optional(),
+    name: z.string().optional(),
+    parameters: z.json().optional(),
+    input_schema: z.json().optional(),
+    strict: z.boolean().nullable().optional(),
+    function: z
+        .object({
+        name: z.string(),
+        parameters: z.json().optional(),
+        strict: z.boolean().nullable().optional(),
+    })
+        .optional(),
+});
+const wireRequest = z.object({
+    model: z.string().optional(),
+    tools: z.array(wireTool).optional(),
+    tool_choice: z
+        .union([
+        z.enum(["auto", "none", "required"]),
+        z.object({
+            type: z.string().max(64),
+            name: z.string().max(256).optional(),
+            function: z.object({ name: z.string().max(256) }).optional(),
+            disable_parallel_tool_use: z.boolean().optional(),
+        }),
+    ])
+        .optional(),
+    system: z.json().optional(),
+    instructions: z.json().optional(),
+    messages: z
+        .array(z.object({ role: z.string(), content: z.json().optional() }))
+        .optional(),
+    input: z
+        .union([
+        z.string(),
+        z.array(z
+            .object({ role: z.string().optional(), content: z.json().optional() })
+            .passthrough()),
+    ])
+        .optional(),
+    temperature: z.number().nullable().optional(),
+    top_p: z.number().nullable().optional(),
+    max_tokens: z.number().optional(),
+    max_completion_tokens: z.number().optional(),
+    max_output_tokens: z.number().optional(),
+    parallel_tool_calls: z.boolean().optional(),
+    stream: z.boolean().optional(),
+    reasoning_effort: z.string().optional(),
+    reasoning: z.object({ effort: z.string().optional() }).optional(),
+    thinking: z
+        .object({
+        type: z.string().optional(),
+        budget_tokens: z.number().optional(),
+    })
+        .optional(),
+});
+/** Called after codec/default merging, immediately before transport. Never retain
+ * headers, endpoints, user messages, schema text, or arbitrary provider options. */
+export async function recordModelRequest(body, format, span = trace.getActiveSpan()) {
+    if (!span?.isRecording())
+        return;
+    const parsed = wireRequest.safeParse(typeof body === "string" ? JSON.parse(body) : body);
+    if (!parsed.success) {
+        span.setAttribute("gea.model.diagnostics.status", "unsupported-request-shape");
+        return;
+    }
+    const { tools, system, instructions, messages, input, ...parameters } = parsed.data;
+    const definitions = await Promise.all((tools ?? []).slice(0, 128).map(async (tool) => {
+        const definition = tool.function ?? tool;
+        return {
+            name: definition.name?.slice(0, 256),
+            type: tool.type ?? "function",
+            schemaSha256: await canonicalHash(definition.parameters ?? tool.input_schema ?? null),
+            strict: definition.strict ?? null,
+        };
+    }));
+    const systemMessages = (messages ?? (Array.isArray(input) ? input : []))
+        .filter((message) => message.role === "system" || message.role === "developer")
+        .map((message) => ({ role: message.role, content: message.content }));
+    const scope = context.active().getValue(modelDiagnosticContext);
+    span.setAttributes({
+        "gea.model.diagnostics.version": 1,
+        "gea.model.request.format": format,
+        "gea.model.request.parameters": JSON.stringify(parameters),
+        "gea.model.tools": JSON.stringify(definitions),
+        "gea.model.tools.count": tools?.length ?? 0,
+        "gea.model.tools.sha256": await canonicalHash(tools ?? []),
+        "gea.model.system.sha256": await canonicalHash({
+            system,
+            instructions,
+            messages: systemMessages,
+        }),
+        ...(scope?.skillsSha256
+            ? { "gea.model.skills.sha256": scope.skillsSha256 }
+            : {}),
+    });
+}

package/dist/tracing.js

@@ -1,3 +1,4 @@
+import { modelDiagnosticContext, } from "./model-diagnostics.js";
 import { agentSdkVersion } from "./version.js";
 import { Result } from "better-result";
 import { captureTraceContext } from "./trace-context.js";
@@ -166,7 +167,9 @@ export async function traceWorkerRequest(request, name, attributes, execute) {
         exports: new Set(),
         errors: [],
     };
-    const parent = extractTraceContext(request.headers).setValue(requestTraceScope, scope);
+    const parent = extractTraceContext(request.headers)
+        .setValue(requestTraceScope, scope)
+        .setValue(modelDiagnosticContext, {});
     const span = currentProvider
         .getTracer("gea.agent-sdk", agentSdkVersion)
         .startSpan(name, {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const agentSdkVersion = "0.1.261019-alpha.1";
+export declare const agentSdkVersion = "0.1.261021-alpha.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/build-sdk-version.mjs from package.json.
-export const agentSdkVersion = "0.1.261019-alpha.1";
+export const agentSdkVersion = "0.1.261021-alpha.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.261019-alpha.1",
+  "version": "0.1.261021-alpha.0",
   "private": false,
   "homepage": "https://musegea.com/developers",
   "license": "Apache-2.0",
@@ -123,7 +123,7 @@
     "@ai-sdk/otel": "1.0.119",
     "@ai-sdk/provider": "4.0.19",
     "@ai-sdk/provider-utils": "5.0.50",
-    "@gea-ai/contract": "0.1.261019-alpha.1",
+    "@gea-ai/contract": "0.1.261021-alpha.0",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",