@gea-ai/agent-sdk 0.1.261020-alpha.0 → 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-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,

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.261020-alpha.0";
+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.261020-alpha.0";
+export const agentSdkVersion = "0.1.261021-alpha.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.261020-alpha.0",
+  "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.261020-alpha.0",
+    "@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",