@gea-ai/agent-sdk 0.1.261008-alpha.0 → 0.1.261009-alpha.1

package/THIRD_PARTY_NOTICES.md

@@ -58,6 +58,13 @@ and packaged Worker conformance fixtures before changing the pin.
 
 ## Agent Core WASM
 
+The bundled Core's Anthropic output-schema sanitizer is ported from
+`@ai-sdk/anthropic` **4.0.67**, `src/sanitize-json-schema.ts` (Vercel AI SDK).
+Copyright 2023 Vercel, Inc.; see
+[license and notice](./third-party/anthropic-schema/LICENSE).
+The Rust port retains the upstream transformation using `serde_json` values;
+the original schema still controls final validation.
+
 The optional Agent Core asset is built from this repository's Apache-2.0 Rust
 crate with Rust 1.94.1. Its Cargo dependencies are pinned in
 `crates/agent-core/Cargo.lock`; exact-version license copies and a dependency

package/dist/agent-session-inbox.js

@@ -633,13 +633,18 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     canonicalAgentChannelJson(input.identity))
                     return Response.json({ error: "session_identity_conflict" }, { status: 409 });
                 if (state.execution?.id === input.executionId) {
-                    if (path === "/v1/inbox/start") {
-                        if (state.started)
-                            return Response.json({ error: "execution_already_started" }, {
-                                status: 409,
-                                headers: { "x-gea-session-execution": "already-started" },
-                            });
-                        state.started = true;
+                    if (input.runId && input.runId !== state.execution.turnId)
+                        return Response.json({ error: "execution_mismatch" }, { status: 409 });
+                    if (path === "/v1/inbox/start" && state.started)
+                        return Response.json({ error: "execution_already_started" }, {
+                            status: 409,
+                            headers: { "x-gea-session-execution": "already-started" },
+                        });
+                    if (!state.started) {
+                        // An inbox claim retains the previous transport until the Host
+                        // admits this execution with its current Run authority.
+                        state.transport = input.transport;
+                        state.started = path === "/v1/inbox/start";
                         await save(tx, state, runs);
                     }
                     return Response.json({ execution: state.execution });

package/dist/agent-worker-context.js

@@ -66,6 +66,62 @@ function groupMessages(messages) {
     }
     return groups;
 }
+// Provider usage is request-wide, not per message. This deliberately estimates
+// content only: UTF-8 bytes / 3 plus framing, without opaque reasoning signatures
+// or base64 expansion. Media gets a fixed allowance, not an exact token count.
+function estimateMessageTokens(message) {
+    const textTokens = (text) => Math.ceil(new TextEncoder().encode(text).length / 3);
+    const mediaTokens = 4_096;
+    if (typeof message.content === "string")
+        return 8 + textTokens(message.content);
+    return (8 +
+        message.content.reduce((total, part) => {
+            switch (part.type) {
+                case "text":
+                case "reasoning":
+                    return total + 8 + textTokens(part.text);
+                case "image":
+                case "reasoning-file":
+                    return total + mediaTokens;
+                case "file":
+                    return (total +
+                        (typeof part.data === "object" &&
+                            "type" in part.data &&
+                            part.data.type === "text"
+                            ? textTokens(part.data.text)
+                            : mediaTokens));
+                case "tool-call":
+                    return (total +
+                        16 +
+                        textTokens(part.toolName) +
+                        textTokens(JSON.stringify(part.input) ?? ""));
+                case "tool-result": {
+                    const output = part.output;
+                    let tokens;
+                    switch (output.type) {
+                        case "content":
+                            tokens = output.value.reduce((count, item) => count +
+                                (item.type === "text"
+                                    ? textTokens(item.text)
+                                    : item.type === "file" && item.data.type === "text"
+                                        ? textTokens(item.data.text)
+                                        : mediaTokens), 0);
+                            break;
+                        case "text":
+                        case "error-text":
+                            tokens = textTokens(output.value);
+                            break;
+                        default:
+                            tokens = textTokens(JSON.stringify(output));
+                    }
+                    return total + 16 + textTokens(part.toolName) + tokens;
+                }
+                default: {
+                    return total + 8 + textTokens(JSON.stringify(part));
+                }
+            }
+        }, 0));
+}
 function getToolOutputText(part) {
     switch (part.output.type) {
         case "error-text":
@@ -224,7 +280,7 @@ export async function applyAgentWorkerToolOutputOffload(input) {
         return input.messages;
     const groups = groupMessages(input.messages);
     const firstProtectedIndex = input.protectRecentGroups
-        ? Math.max(0, groups.length - input.options.preserveRecentGroups)
+        ? Math.max(0, groups.length - (input.options.preserveRecentGroups ?? 5))
         : groups.length;
     const messages = [];
     for (const [groupIndex, group] of groups.entries()) {
@@ -263,13 +319,135 @@ function summarySchema() {
         "## Critical Exact Details\n- Preserve exact IDs, commands, paths, API names, error messages, and config values.",
     ].join("\n\n");
 }
+// Summary input is a textual projection, not a provider request. Keep resource
+// references for recovery but never stringify media bytes or opaque metadata.
+function summaryFileData(data) {
+    if (data instanceof URL) {
+        return data.protocol === "data:"
+            ? { omitted: "inline media bytes" }
+            : { url: data.href };
+    }
+    if (typeof data === "string" ||
+        data instanceof ArrayBuffer ||
+        ArrayBuffer.isView(data)) {
+        return { omitted: "inline media bytes; recover from raw chat history" };
+    }
+    if ("type" in data) {
+        switch (data.type) {
+            case "text":
+                return { text: data.text };
+            case "url": {
+                const url = String(data.url);
+                return url.startsWith("data:")
+                    ? { omitted: "inline media bytes" }
+                    : { url };
+            }
+            case "reference":
+                return { reference: data.reference };
+            case "data":
+                return { omitted: "inline media bytes; recover from raw chat history" };
+        }
+    }
+    return { reference: data };
+}
+function summaryContentPart(part) {
+    switch (part.type) {
+        case "text":
+        case "reasoning":
+            return { type: part.type, text: part.text };
+        case "tool-call":
+            return {
+                type: part.type,
+                toolName: part.toolName,
+                toolCallId: part.toolCallId,
+                input: part.input,
+                providerExecuted: part.providerExecuted,
+            };
+        case "tool-result": {
+            const output = part.output;
+            return {
+                type: part.type,
+                toolName: part.toolName,
+                toolCallId: part.toolCallId,
+                output: output.type === "content"
+                    ? { type: output.type, value: output.value.map(summaryContentPart) }
+                    : output.type === "execution-denied"
+                        ? { type: output.type, reason: output.reason }
+                        : { type: output.type, value: output.value },
+            };
+        }
+        case "file":
+        case "file-data":
+            return {
+                type: part.type,
+                mediaType: part.mediaType,
+                filename: part.filename,
+                data: summaryFileData(part.data),
+            };
+        case "image":
+            return {
+                type: part.type,
+                mediaType: part.mediaType,
+                data: summaryFileData(part.image),
+            };
+        case "image-data":
+        case "reasoning-file":
+            return {
+                type: part.type,
+                mediaType: part.mediaType,
+                data: summaryFileData(part.data),
+            };
+        case "file-url":
+        case "image-url":
+            return {
+                type: part.type,
+                mediaType: "mediaType" in part ? part.mediaType : undefined,
+                url: part.url.startsWith("data:") ? "[inline media omitted]" : part.url,
+            };
+        case "file-id":
+        case "image-file-id":
+            return { type: part.type, fileId: part.fileId };
+        case "file-reference":
+        case "image-file-reference":
+            return { type: part.type, reference: part.providerReference };
+        case "custom":
+            return {
+                type: part.type,
+                kind: "kind" in part ? part.kind : undefined,
+                omitted: "opaque provider content; recover from raw chat history",
+            };
+        case "tool-approval-request":
+        case "tool-approval-response":
+            return part;
+    }
+}
+function summaryMessage(message) {
+    return {
+        role: message.role,
+        content: typeof message.content === "string"
+            ? message.content
+            : message.content.map(summaryContentPart),
+    };
+}
 function buildSummaryMessages(input) {
+    const latestRequest = [...input.recentTailMessages]
+        .reverse()
+        .find((message) => message.role === "user");
+    const requestText = latestRequest
+        ? JSON.stringify(summaryMessage(latestRequest))
+        : "(no new user request in the retained tail)";
+    // The tail remains verbatim in the main context. A bounded task excerpt is
+    // enough for the summarizer; duplicating retained tool payloads adds no memory.
+    const requestExcerpt = requestText.length <= 6_000
+        ? requestText
+        : `${requestText.slice(0, 6_000)}\n[excerpt truncated; the complete request remains in the retained context]`;
     return [
         {
             role: "system",
             content: [
                 "Update the compact working-memory summary for an agent.",
                 "Merge the previous summary with the older messages being compacted.",
+                "The recent user request is orientation only. Recent messages remain verbatim; do not repeat them in the summary. Omitted media and provider content remain in raw chat history; do not infer their contents.",
                 "Preserve requirements, decisions, exact paths, commands, IDs, errors, tool observations, offloaded artifact references, open questions, and next steps.",
                 "Do not invent facts, expose hidden reasoning, or issue new instructions.",
                 "Do not copy full offloaded artifacts. Keep their paths and relevant preview facts.",
@@ -284,11 +462,11 @@ function buildSummaryMessages(input) {
                 input.previousSummary ?? "(none)",
                 "</previous_summary>",
                 "<messages>",
-                JSON.stringify(input.compactableMessages, null, 2),
+                JSON.stringify(input.compactableMessages.map(summaryMessage)),
                 "</messages>",
-                "<recent_tail>",
-                JSON.stringify(input.recentTailMessages, null, 2),
-                "</recent_tail>",
+                "<recent_user_request>",
+                requestExcerpt,
+                "</recent_user_request>",
             ].join("\n"),
         },
     ];
@@ -389,7 +567,44 @@ export async function compactAgentWorkerContext(input) {
         return { summaryUsage: null, messagesUpdated };
     }
     const groups = groupMessages(input.context.messages);
-    const splitIndex = Math.max(0, groups.length - options.preserveRecentGroups);
+    const recentTokenBudget = options.preserveRecentTokens ??
+        Math.max(1, Math.min(16_000, Math.floor(summarization.triggerAtTotalTokens / 4)));
+    const groupEstimates = groups.map((group) => group.messages.reduce((total, message) => total + estimateMessageTokens(message), 0));
+    const previousSummary = input.context.metadata.contextSummary?.summaryText;
+    const projectionEstimate = groupEstimates.reduce((total, tokens) => total + tokens, 0) +
+        (previousSummary
+            ? estimateMessageTokens(makeSummaryMessage(previousSummary))
+            : 0);
+    // Usage includes fixed prompt overhead we cannot attribute to individual messages.
+    // Allocate it conservatively across the projection instead of treating small
+    // local estimates as proof that an over-threshold request already fits.
+    const usageScale = Math.max(1, (input.context.contextSize ?? 0) / Math.max(1, projectionEstimate));
+    let splitIndex = groups.length;
+    let retainedTokens = 0;
+    while (splitIndex > 0) {
+        const groupTokens = Math.ceil(groupEstimates[splitIndex - 1] * usageScale);
+        // Always keep the newest complete group, even when it exceeds the budget.
+        if (splitIndex < groups.length &&
+            (retainedTokens + groupTokens > recentTokenBudget ||
+                (options.preserveRecentGroups !== undefined &&
+                    groups.length - splitIndex >= options.preserveRecentGroups)))
+            break;
+        retainedTokens += groupTokens;
+        splitIndex--;
+    }
+    // Fixed overhead alone is not a reason to pay for summarizing a tiny history.
+    // Explicit retention limits still take precedence over this default safeguard.
+    if (options.preserveRecentTokens === undefined &&
+        options.preserveRecentGroups === undefined &&
+        groupEstimates
+            .slice(0, splitIndex)
+            .reduce((total, tokens) => total + tokens, 0) <
+            Math.max(1, Math.min(1_024, Math.floor(recentTokenBudget / 4)))) {
+        createAgentTracing().currentSpan?.setAttributes({
+            "gea.context.compaction.skip_reason": "insufficient_reduction",
+        });
+        return { summaryUsage: null, messagesUpdated };
+    }
     const compactableMessages = groups
         .slice(0, splitIndex)
         .flatMap((group) => group.messages)
@@ -433,7 +648,18 @@ export async function compactAgentWorkerContext(input) {
                 if (part.type === "content_delta" && kinds.get(part.id) === "text")
                     summaryText += part.delta;
             }
-            summaryUsage = (await result.result).usage;
+            const completion = await result.result;
+            summaryUsage = completion.usage;
+            if (completion.finishReason !== "stop") {
+                // The provider call still counts toward usage, but an incomplete
+                // summary must not replace the previous summary or active history.
+                span.setAttributes({
+                    "gea.context.compaction.outcome": "rejected",
+                    "gea.context.compaction.finish_reason": completion.finishReason,
+                    "gea.context.messages.output_count": input.context.messages.length,
+                });
+                return { summaryUsage, messagesUpdated };
+            }
             if (!summaryText.trim())
                 throw new Error("Context summary was empty.");
             const missingHeadings = REQUIRED_SUMMARY_HEADINGS.filter((heading) => !summaryText.includes(heading));
@@ -480,7 +706,11 @@ export async function compactAgentWorkerContext(input) {
             "gea.context.tokens.estimate": input.context.contextSize ?? undefined,
             "gea.context.tokens.threshold": summarization.triggerAtTotalTokens,
             "gea.context.messages.compacted_count": compactableMessages.length,
-            "gea.context.groups.preserved": options.preserveRecentGroups,
+            "gea.context.groups.preserved": groups.length - splitIndex,
+            "gea.context.tokens.retained_estimate": retainedTokens,
+            "gea.context.tokens.usage_scale": usageScale,
+            "gea.context.tokens.retained_budget": recentTokenBudget,
+            "gea.context.tokens.retained_over_budget": retainedTokens > recentTokenBudget,
         },
     });
 }

package/dist/agent-worker.js

@@ -1,3 +1,4 @@
+import { contextSystemInputSchema } from "@gea-ai/contract/agent-worker-tools";
 import { getAgentProgrammaticToolCalling, isAgentConnectorConnectionHelperExposed, } from "@gea-ai/contract/agent-packages";
 import { AGENT_WORKER_TOOL_METADATA_HEADER, AGENT_WORKER_TOOL_METADATA_VERSION, } from "@gea-ai/contract/agent-worker-tools";
 import { isAgentConnectorExposed } from "@gea-ai/contract/agent-packages";
@@ -2232,6 +2233,21 @@ function createHostBackedAgentTools(input) {
                 inputSchema: webSearchInputSchema,
             });
         }
+        else if (definition.id === "context_system") {
+            registerAgentWorkerTool(tools, "contextSystem", tool({
+                description: "Access the current OAuth user's GEA Context resources. Call action=list to discover operations and their input schemas, then action=call with tool and arguments. Documents use Markdown; read before editing and retain contentHash for conflict checks. Requires OAuth; Project keys, custom principals and local calls are unsupported.",
+                inputSchema: contextSystemInputSchema,
+                toModelOutput: mcpToolModelOutput,
+                execute: async (toolInput, options) => invokeHostTool({
+                    host: input.host,
+                    messages: options.messages,
+                    signal: options.abortSignal,
+                    toolCallId: options.toolCallId,
+                    toolInput,
+                    toolName: definition.id,
+                }),
+            }));
+        }
         else if (definition.id === "agent") {
             // The negotiated target catalog below owns registration, including declared subagents.
         }
@@ -2570,7 +2586,6 @@ async function requestSessionJson(input) {
             method: input.method,
         })),
     });
-    input.onResponse?.(response);
     if (!response.ok)
         throw new Error(`AgentSession rejected ${input.path} (${response.status}).`);
     return input.schema.parse(await response.json());
@@ -3027,15 +3042,9 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     }
     const mutateSession = (values) => {
         const queuedAt = performance.now();
-        const mutationSpan = trace
-            .getTracer("gea.agent-session")
-            .startSpan("agent.session.mutation", {
-            attributes: { "gea.agent.run.id": payload.runId },
-        });
         const result = writeTail.then(async () => {
             const startedAt = performance.now();
             const queueMs = startedAt - queuedAt;
-            const sequence = mutationSequence;
             let failed = true;
             try {
                 if (writeFailure)
@@ -3047,12 +3056,6 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                     namespace: input.sessionNamespace,
                     path: "/v2/mutations",
                     schema: agentSessionExecutionMutationResultSchema,
-                    onResponse(response) {
-                        mutationSpan.setAttribute("http.response.status_code", response.status);
-                        const timing = response.headers.get("server-timing");
-                        if (timing)
-                            mutationSpan.setAttribute("gea.session.mutation.server_timing", timing);
-                    },
                 });
                 mutationSequence += 1;
                 failed = false;
@@ -3073,22 +3076,6 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                     "gea.session.persistence.queue_ms": Math.round(persistenceTotals.queueMs),
                     "gea.session.persistence.request_ms": Math.round(persistenceTotals.requestMs),
                 });
-                mutationSpan.setAttributes({
-                    "gea.session.mutation.sequence": sequence,
-                    "gea.session.mutation.kinds": Object.keys(values),
-                    "gea.session.mutation.event_count": values.events?.length ?? 0,
-                    "gea.session.mutation.queue_ms": Math.round(queueMs),
-                    "gea.session.mutation.request_ms": Math.round(requestMs),
-                    ...(invocationTiming.lastModelFinishedAt === undefined
-                        ? {}
-                        : {
-                            "gea.session.mutation.start_after_model_ms": Math.round(startedAt - invocationTiming.lastModelFinishedAt),
-                            "gea.session.mutation.end_after_model_ms": Math.round(performance.now() - invocationTiming.lastModelFinishedAt),
-                        }),
-                });
-                if (failed)
-                    mutationSpan.setStatus({ code: SpanStatusCode.ERROR });
-                mutationSpan.end();
                 if (failed || queueMs + requestMs >= 250)
                     console.info("AgentSession mutation timing", {
                         runId: payload.runId,
@@ -4220,6 +4207,9 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     };
     let terminalMessage;
     let terminalEvent;
+    // Inbox suspension is a live protocol frame, not a journaled response end.
+    // Hold it until the final context commit so a failed commit cannot publish waiting.
+    let liveFinish;
     const saveResponseMessage = async ({ responseMessage, }) => {
         const saveStartedAt = performance.now();
         const metadata = await contextFinished;
@@ -4237,6 +4227,21 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         }
         if (inboxRunner?.suspended)
             context.metadata.suspendedMessageId = responseMessage.id;
+        const needsInput = !inboxRunner?.suspended &&
+            responseMessage.parts.some((part) => "state" in part &&
+                (part.state === "approval-requested" ||
+                    (part.state === "input-available" &&
+                        input.snapshot.tools.some((tool) => tool.type === "custom" &&
+                            tool.execution === "client" &&
+                            part.type === `tool-${tool.name}`))));
+        // The same metadata object is held by the deferred finish frame. Do not
+        // publish waiting until the final context commit succeeds; a failed commit
+        // seals the call as failed and must not leave the message looking suspended.
+        const markWaiting = !failure &&
+            (needsInput ||
+                Boolean(inboxRunner?.suspended && metadata.sessionStatus === "waiting"));
+        if (markWaiting)
+            delete metadata.sessionStatus;
         responseMessage.metadata = {
             ...responseMessage.metadata,
             ...metadata,
@@ -4289,19 +4294,39 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             }
             throw error;
         }
+        if (markWaiting) {
+            metadata.sessionStatus = "waiting";
+            responseMessage.metadata = {
+                ...responseMessage.metadata,
+                sessionStatus: "waiting",
+            };
+            if (terminalMessage) {
+                terminalMessage = {
+                    ...terminalMessage,
+                    metadata: {
+                        ...terminalMessage.metadata,
+                        sessionStatus: "waiting",
+                    },
+                };
+            }
+            else if (sessionExecution) {
+                await mutateSession({ messages: [{ ...responseMessage }] });
+            }
+            else {
+                await appendSessionValue({
+                    body: { message: responseMessage, runId: payload.runId },
+                    chatId: payload.chatId,
+                    namespace: input.sessionNamespace,
+                    path: "/v1/messages",
+                });
+            }
+        }
         const contextPersistedAt = performance.now();
         persistenceSpan?.setAttributes({
             "gea.session.finish.context_wait_ms": Math.round(contextFinishedAt - saveStartedAt),
             "gea.session.finish.transcript_ms": Math.round(transcriptFinishedAt - transcriptStartedAt),
             "gea.session.finish.context_write_ms": Math.round(contextPersistedAt - transcriptFinishedAt),
         });
-        const needsInput = !inboxRunner?.suspended &&
-            responseMessage.parts.some((part) => "state" in part &&
-                (part.state === "approval-requested" ||
-                    (part.state === "input-available" &&
-                        input.snapshot.tools.some((tool) => tool.type === "custom" &&
-                            tool.execution === "client" &&
-                            part.type === `tool-${tool.name}`))));
         ownSessionOutcome({
             ...(needsInput
                 ? {
@@ -4970,14 +4995,19 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                         finishReason: metadata.finishReason,
                         messageMetadata: metadata,
                     };
-                    if (metadata.sessionStatus === "waiting") {
-                        controller.enqueue(chunk);
+                    if (inboxRunner?.suspended && metadata.finishReason !== "error") {
+                        // onFinish commits context before this frame is published. The
+                        // journal keeps the resumed response's finish, not this boundary.
+                        liveFinish = chunk;
                         continue;
                     }
-                    if (sessionExecution &&
-                        !input.channelJournal &&
-                        !inboxRunner?.suspended &&
-                        metadata.finishReason === "stop") {
+                    if (metadata.finishReason === "tool-calls" ||
+                        (sessionExecution &&
+                            !input.channelJournal &&
+                            !inboxRunner?.suspended &&
+                            metadata.finishReason === "stop")) {
+                        // onFinish commits context before publishing waiting metadata.
+                        // Flush emits this frame only after that commit returns.
                         terminalEvent = chunk;
                         continue;
                     }
@@ -4995,16 +5025,26 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 controller.enqueue(event);
         },
         async flush(controller) {
-            if (!terminalMessage && !terminalEvent)
+            if (!terminalMessage && !terminalEvent && !liveFinish)
                 return;
-            const startedAt = performance.now();
-            await mutateSession({
-                ...(terminalMessage ? { messages: [{ ...terminalMessage }] } : {}),
-                ...(terminalEvent ? { events: [terminalEvent] } : {}),
-            });
-            persistenceSpan?.setAttribute("gea.session.finish.transcript_ms", Math.round(performance.now() - startedAt));
+            if (terminalMessage || terminalEvent) {
+                const startedAt = performance.now();
+                if (sessionExecution) {
+                    await mutateSession({
+                        ...(terminalMessage
+                            ? { messages: [{ ...terminalMessage }] }
+                            : {}),
+                        ...(terminalEvent ? { events: [terminalEvent] } : {}),
+                    });
+                }
+                else if (terminalEvent)
+                    await appendStreamEvent(terminalEvent);
+                persistenceSpan?.setAttribute("gea.session.finish.transcript_ms", Math.round(performance.now() - startedAt));
+            }
             if (terminalEvent)
                 controller.enqueue(terminalEvent);
+            if (liveFinish)
+                controller.enqueue(liveFinish);
         },
     }));
     if (engine || sessionExecution) {

package/dist/index.d.ts

@@ -429,7 +429,7 @@ type CustomAgentToolDefinition = {
     readonly type: "custom";
     readonly [agentToolConnectorAliases]?: Readonly<Record<string, string>>;
 };
-type ManagedToolId = "agent" | "chat_list" | "chat_read" | "chat_send" | "web_search";
+type ManagedToolId = "agent" | "chat_list" | "chat_read" | "chat_send" | "web_search" | "context_system";
 export type DefinedManagedTool<TId extends ManagedToolId = ManagedToolId> = {
     readonly id: TId;
     readonly type: "managed";
@@ -477,6 +477,8 @@ export declare function chatRead(): DefinedManagedTool<"chat_read">;
 /** @deprecated Enable defineAgent({ sessionTools: true }) instead. */
 export declare function chatSend(): DefinedManagedTool<"chat_send">;
 export declare function webSearch(): DefinedManagedTool<"web_search">;
+/** Access the current OAuth user's GEA Context without a separate Connection. */
+export declare function contextSystem(): DefinedManagedTool<"context_system">;
 type LegacyAgentToolPreset = {
     readonly preset: "coding" | "default";
     readonly type: "preset";

package/dist/index.js

@@ -368,6 +368,10 @@ export function chatSend() {
 export function webSearch() {
     return { id: "web_search", type: "managed" };
 }
+/** Access the current OAuth user's GEA Context without a separate Connection. */
+export function contextSystem() {
+    return { id: "context_system", type: "managed" };
+}
 export function defineToolSet(tools) {
     return { tools, type: "tool-set" };
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const agentSdkVersion = "0.1.261008-alpha.0";
+export declare const agentSdkVersion = "0.1.261009-alpha.1";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.261008-alpha.0",
+  "version": "0.1.261009-alpha.1",
   "private": false,
   "homepage": "https://musegea.com/developers",
   "license": "Apache-2.0",
@@ -119,7 +119,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.261008-alpha.0",
+    "@gea-ai/contract": "0.1.261009-alpha.1",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",

package/third-party/anthropic-schema/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Vercel, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.