@gea-ai/agent-sdk 0.1.260916-alpha.2 → 0.1.260917-alpha.0

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

@@ -19,19 +19,6 @@ 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;
 } | {
@@ -56,6 +43,19 @@ 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-worker.d.ts

@@ -18,6 +18,7 @@ import { type AgentChannelJournalAppend } from "@gea-ai/contract/agent-channel-r
 import { type AgentDurableObjectNamespace, type AgentToolApprovalDecision, type AgentToolIdentity, type AgentToolRuntimeSdk, type DefinedAgentPackage } from "./index";
 import { type AgentChannelAddressEnvironment } from "./agent-channel-worker";
 export { handleAgentChannelAddressAlarm, handleAgentChannelAddressRequest, type AgentChannelAddressEnvironment, type AgentChannelAddressStorage, type AgentChannelAddressTransactionStorage, } from "./agent-channel-worker";
+declare const jsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
 export type AgentHostBinding = {
     fetch(path: string, init?: RequestInit): Promise<Response>;
 };
@@ -191,7 +192,7 @@ export type AgentSessionNamespace = {
     };
     idFromName(name: string): unknown;
 };
-export declare function createGeaAI(host: AgentHostBinding, publicModel: string, extraBody?: Record<string, unknown>, client?: AgentModelProxyClient): Promise<LanguageModel>;
+export declare function createGeaAI(host: AgentHostBinding, publicModel: string, extraBody?: Record<string, unknown>, client?: AgentModelProxyClient, requestBody?: z.infer<typeof jsonObjectSchema>): Promise<LanguageModel>;
 export declare function runAgentWorkerRequest(input: {
     interactionPolicy?: AgentInteractionPolicy;
     initialization?: AgentWorkerToolInitialization;

package/dist/agent-worker.js

@@ -1,3 +1,5 @@
+import { moveOpenAICompatibleCacheControlToMessageContent as moveOpenAiCompatibleCacheControlToContent, createCatalogLanguageModel, } from "./catalog-language-model.js";
+import { mergeLlmJson, llmRuntimeRequestOptionsSchema, } from "@gea-ai/contract/llm-catalog";
 import { agentWorkerAttachmentOutputSchema } from "@gea-ai/contract/agent-api-host";
 import { streamManagedAgentSessionRun } from "./agent-session-stream.js";
 import { agentSessionReadToolOutputSchema, agentSessionReadToolOutputResultSchema, } from "@gea-ai/contract/agent-session";
@@ -60,12 +62,7 @@ const modelDescriptorSchema = z.union([
     z.object({ transport: z.literal(AGENT_MODEL_PROXY_TRANSPORT) }).strict(),
 ]);
 const jsonObjectSchema = z.record(z.string(), z.json());
-const modelRequestOptionsSchema = z
-    .object({
-    extraBody: jsonObjectSchema.optional(),
-    providerOptions: z.record(z.string(), jsonObjectSchema).optional(),
-})
-    .strict();
+const modelRequestOptionsSchema = llmRuntimeRequestOptionsSchema;
 function mergeModelProviderOptions(defaults, overrides) {
     const merged = { ...defaults };
     for (const [provider, options] of Object.entries(overrides ?? {})) {
@@ -2373,50 +2370,6 @@ function mergeRequestBodyExtra(body, extraBody) {
     }
     return merged;
 }
-function moveOpenAiCompatibleCacheControlToContent(body) {
-    if (!Array.isArray(body.messages))
-        return body;
-    return {
-        ...body,
-        messages: body.messages.map((message) => {
-            if (!isJsonObject(message) ||
-                !("cache_control" in message) ||
-                message.cache_control == null) {
-                return message;
-            }
-            const { cache_control: cacheControl, content, ...rest } = message;
-            if (typeof content === "string") {
-                return {
-                    ...rest,
-                    content: [
-                        { cache_control: cacheControl, text: content, type: "text" },
-                    ],
-                };
-            }
-            if (!Array.isArray(content))
-                return message;
-            if (content.some((part) => isJsonObject(part) && "cache_control" in part)) {
-                return { ...rest, content };
-            }
-            let textPartIndex = -1;
-            for (let index = content.length - 1; index >= 0; index -= 1) {
-                const part = content[index];
-                if (isJsonObject(part) && part.type === "text") {
-                    textPartIndex = index;
-                    break;
-                }
-            }
-            return textPartIndex < 0
-                ? message
-                : {
-                    ...rest,
-                    content: content.map((part, index) => index === textPartIndex && isJsonObject(part)
-                        ? { ...part, cache_control: cacheControl }
-                        : part),
-                };
-        }),
-    };
-}
 function serializeHostedModelCallOptions(options) {
     const { abortSignal: _abortSignal, ...serializableOptions } = options;
     return serializableOptions;
@@ -2501,12 +2454,13 @@ function createHostedGeaLanguageModel(input) {
     };
 }
 async function createGeaCoreConnection(host, publicModel, requestOptions, signal, maxOutputTokens) {
-    const descriptor = modelDescriptorSchema.parse(await requireHostJson(host, `/model?model=${encodeURIComponent(publicModel)}&transport=agent-core&includeMaxOutputTokens=true`, { signal }));
+    const descriptor = modelDescriptorSchema.parse(await requireHostJson(host, `/model?model=${encodeURIComponent(publicModel)}&transport=agent-core&includeMaxOutputTokens=true&includeCatalogConfig=true`, { signal }));
     if ("transport" in descriptor)
         throw new Error("Agent Core requires the raw model transport.");
-    const format = descriptor.providerType === "anthropic"
-        ? "anthropic-messages"
-        : "openai-completions";
+    const format = descriptor.format ??
+        (descriptor.providerType === "anthropic"
+            ? "anthropic-messages"
+            : "openai-completions");
     const resolvedMaxOutputTokens = maxOutputTokens ?? descriptor.maxOutputTokens;
     const provider = agentCoreProviderConfigSchema.parse({
         format,
@@ -2516,10 +2470,14 @@ async function createGeaCoreConnection(host, publicModel, requestOptions, signal
                 descriptor.includeUsage === false
                 ? { stream_options: { include_usage: false } }
                 : {}),
-            ...descriptor.requestOptions?.extraBody,
-            ...requestOptions?.extraBody,
+            ...mergeLlmJson(requestOptions?.requestBody ??
+                descriptor.requestOptions?.requestBody ??
+                descriptor.requestOptions?.extraBody, requestOptions?.extraBody),
         },
         generation: {
+            ...(descriptor.compat?.maxTokensField
+                ? { max_tokens_field: descriptor.compat.maxTokensField }
+                : {}),
             ...fromAiSdkProviderOptions(format, mergeModelProviderOptions(descriptor.requestOptions?.providerOptions, requestOptions?.providerOptions)),
             ...(resolvedMaxOutputTokens === undefined
                 ? {}
@@ -2530,7 +2488,7 @@ async function createGeaCoreConnection(host, publicModel, requestOptions, signal
         if (typeof init?.body !== "string")
             throw new Error("Core provider request must contain JSON text.");
         const headers = new Headers(init.headers);
-        return host.fetch(`${HOST_PATH}/model/provider-fetch?model=${encodeURIComponent(publicModel)}`, {
+        return host.fetch(`${HOST_PATH}/model/provider-fetch?model=${encodeURIComponent(publicModel)}&includeCatalogConfig=true`, {
             method: "POST",
             body: init.body,
             signal: init.signal,
@@ -2545,14 +2503,16 @@ async function createGeaCoreConnection(host, publicModel, requestOptions, signal
     return {
         provider,
         fetch,
-        cacheControlProvider: descriptor.cacheControlProvider ??
-            (descriptor.providerType === "anthropic"
-                ? "anthropic"
-                : undefined),
+        cacheControlProvider: descriptor.cacheControl === "off"
+            ? undefined
+            : (descriptor.cacheControlProvider ??
+                (descriptor.providerType === "anthropic"
+                    ? "anthropic"
+                    : undefined)),
     };
 }
-export async function createGeaAI(host, publicModel, extraBody, client) {
-    const descriptor = modelDescriptorSchema.parse(await requireHostJson(host, `/model?model=${encodeURIComponent(publicModel)}&includeModelId=true&includeMaxOutputTokens=true`));
+export async function createGeaAI(host, publicModel, extraBody, client, requestBody) {
+    const descriptor = modelDescriptorSchema.parse(await requireHostJson(host, `/model?model=${encodeURIComponent(publicModel)}&includeModelId=true&includeMaxOutputTokens=true&includeCatalogConfig=true`));
     if ("transport" in descriptor) {
         return createHostedGeaLanguageModel({ client, host, publicModel });
     }
@@ -2562,7 +2522,7 @@ export async function createGeaAI(host, publicModel, extraBody, client) {
         }
         const providerHeaders = new Headers(init.headers);
         const anthropicBeta = providerHeaders.get("anthropic-beta");
-        return await host.fetch(`${HOST_PATH}/model/provider-fetch?model=${encodeURIComponent(publicModel)}`, {
+        return await host.fetch(`${HOST_PATH}/model/provider-fetch?model=${encodeURIComponent(publicModel)}&includeCatalogConfig=true`, {
             body: init.body,
             headers: {
                 ...(anthropicBeta ? { "anthropic-beta": anthropicBeta } : {}),
@@ -2572,6 +2532,35 @@ export async function createGeaAI(host, publicModel, extraBody, client) {
             signal: init.signal,
         });
     };
+    if (descriptor.format) {
+        const model = createCatalogLanguageModel({
+            format: descriptor.format,
+            modelId: descriptor.modelId ?? publicModel,
+            baseURL: "https://gea-ai-binding.invalid/v1",
+            apiKey: "host-managed",
+            auth: "bearer",
+            fetch: providerFetch,
+            includeUsage: descriptor.includeUsage ?? undefined,
+            maxOutputTokens: descriptor.maxOutputTokens,
+            maxTokensField: descriptor.compat?.maxTokensField,
+            requestBody: mergeLlmJson(requestBody ??
+                descriptor.requestOptions?.requestBody ??
+                descriptor.requestOptions?.extraBody, jsonObjectSchema.parse(extraBody ?? {})),
+        });
+        const cache = descriptor.cacheControlProvider;
+        const state = {};
+        return wrapLanguageModel({
+            model,
+            modelId: publicModel,
+            middleware: {
+                transformParams: async ({ params }) => ({
+                    ...params,
+                    prompt: addCacheControlToMessages(params.prompt, cache, state),
+                    tools: addCacheControlToToolList(params.tools, cache, state),
+                }),
+            },
+        });
+    }
     if (descriptor.providerType === "anthropic") {
         if (extraBody && Object.keys(extraBody).length > 0) {
             throw new Error("Anthropic models do not support extra request body fields.");
@@ -3643,7 +3632,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         : await createGeaAI(host, configuredModel, requestOptions.extraBody, {
             kind: "agent-dev",
             packageName: input.snapshot.name,
-        });
+        }, requestOptions.requestBody);
     const modelMessages = replaceInputFiles(await convertToModelMessages(payload.originalMessages), inputFiles);
     // Model file parts can contain URL and byte values that ordinary JSON cannot preserve.
     const runtimeContext = decodeAgentModelProxyValue(payload.runtimeContext);
@@ -3947,7 +3936,9 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 let resolved = models.get(modelId);
                 if (!resolved) {
                     // TS strategies choose their own model features, independently of Core.
-                    resolved = createGeaAI(host, modelId, modelId === configuredModel ? requestOptions.extraBody : undefined, { kind: "agent-dev", packageName: input.snapshot.name });
+                    resolved = createGeaAI(host, modelId, modelId === configuredModel ? requestOptions.extraBody : undefined, { kind: "agent-dev", packageName: input.snapshot.name }, modelId === configuredModel
+                        ? requestOptions.requestBody
+                        : undefined);
                     models.set(modelId, resolved);
                 }
                 return resolved;

package/dist/catalog-language-model.d.ts

@@ -0,0 +1,17 @@
+export { moveOpenAICompatibleCacheControlToMessageContent } from "./openai-compatible-cache-control";
+import { type LlmModelFormat } from "@gea-ai/contract/llm-catalog";
+import { z } from "zod";
+declare const object: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+/** A shared AI SDK adapter for hosted and native Catalog v2 execution. */
+export declare function createCatalogLanguageModel(config: {
+    format: LlmModelFormat;
+    modelId: string;
+    baseURL: string;
+    apiKey: string;
+    auth: "bearer" | "x-api-key";
+    fetch: typeof globalThis.fetch;
+    includeUsage?: boolean;
+    maxOutputTokens?: number;
+    maxTokensField?: "max_tokens" | "max_completion_tokens";
+    requestBody?: z.infer<typeof object>;
+}): import("@ai-sdk/provider").LanguageModelV4;

package/dist/catalog-language-model.js

@@ -0,0 +1,231 @@
+import { moveOpenAICompatibleCacheControlToMessageContent } from "./openai-compatible-cache-control.js";
+export { moveOpenAICompatibleCacheControlToMessageContent } from "./openai-compatible-cache-control.js";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { wrapLanguageModel } from "ai";
+import { resolveAnthropicModelId } from "@gea-ai/contract/model-identity";
+import { llmRequestBodySchema, mergeLlmJson, } from "@gea-ai/contract/llm-catalog";
+import { z } from "zod";
+const object = z.record(z.string(), z.json());
+const controlsSchema = z.object({
+    thinking: z
+        .object({
+        type: z.string(),
+        budget_tokens: z.number().optional(),
+        display: z.string().optional(),
+    })
+        .optional(),
+    output_config: z.object({ effort: z.string().optional() }).optional(),
+    reasoning: z
+        .object({ effort: z.string().optional(), summary: z.string().optional() })
+        .optional(),
+    reasoning_effort: z.string().optional(),
+    temperature: z.number().optional(),
+    top_p: z.number().optional(),
+    presence_penalty: z.number().optional(),
+    frequency_penalty: z.number().optional(),
+    seed: z.number().int().optional(),
+    store: z.boolean().optional(),
+});
+const usageSchema = z.object({
+    input_tokens_details: z
+        .object({ cache_write_tokens: z.number().nonnegative().optional() })
+        .nullish(),
+    prompt_tokens_details: z
+        .object({
+        cache_creation_input_tokens: z.number().nonnegative().optional(),
+    })
+        .nullish(),
+});
+const usageFrameSchema = z.object({
+    usage: usageSchema.nullish(),
+    response: z.object({ usage: usageSchema.nullish() }).optional(),
+});
+/** A shared AI SDK adapter for hosted and native Catalog v2 execution. */
+export function createCatalogLanguageModel(config) {
+    const bodyDefaults = llmRequestBodySchema.parse(config.requestBody ?? {});
+    const controls = controlsSchema.parse(bodyDefaults);
+    const namespace = config.format === "anthropic-messages"
+        ? "anthropic"
+        : config.format === "openai-responses"
+            ? "openai"
+            : "openaiCompatible";
+    const providerDefaults = {};
+    if (config.format === "anthropic-messages") {
+        if (controls.thinking) {
+            const { budget_tokens, ...thinking } = controls.thinking;
+            providerDefaults.thinking = {
+                ...thinking,
+                ...(budget_tokens === undefined ? {} : { budgetTokens: budget_tokens }),
+            };
+        }
+        if (controls.output_config?.effort)
+            providerDefaults.effort = controls.output_config.effort;
+    }
+    else if (config.format === "openai-responses") {
+        providerDefaults.store = controls.store ?? false;
+        if (controls.reasoning) {
+            providerDefaults.forceReasoning = true;
+            if (controls.reasoning.effort)
+                providerDefaults.reasoningEffort = controls.reasoning.effort;
+            if (controls.reasoning.summary)
+                providerDefaults.reasoningSummary = controls.reasoning.summary;
+        }
+    }
+    else if (controls.reasoning_effort)
+        providerDefaults.reasoningEffort = controls.reasoning_effort;
+    // Mapped controls must not be merged back after SDK serialization: doing so
+    // can reintroduce a default thinking budget after an explicit mode change.
+    const extensions = { ...bodyDefaults };
+    for (const key of [
+        "temperature",
+        "top_p",
+        "presence_penalty",
+        "frequency_penalty",
+        "seed",
+    ])
+        delete extensions[key];
+    if (config.format === "anthropic-messages") {
+        if (extensions.thinking) {
+            const { type: _type, budget_tokens: _budget, display: _display, ...rest } = object.parse(extensions.thinking);
+            if (Object.keys(rest).length)
+                extensions.thinking = rest;
+            else
+                delete extensions.thinking;
+        }
+        if (extensions.output_config) {
+            const { effort: _effort, ...rest } = object.parse(extensions.output_config);
+            extensions.output_config = rest;
+        }
+    }
+    else if (config.format === "openai-responses") {
+        delete extensions.store;
+        if (extensions.reasoning) {
+            const { effort: _effort, summary: _summary, ...rest } = object.parse(extensions.reasoning);
+            extensions.reasoning = rest;
+        }
+    }
+    else
+        delete extensions.reasoning_effort;
+    const fetch = async (input, init) => {
+        if (typeof init?.body !== "string")
+            throw new Error("Catalog provider request must be JSON text.");
+        // SDK encoding owns messages, signatures and tools. Merge only parameter defaults.
+        const body = mergeLlmJson(extensions, object.parse(JSON.parse(init.body)));
+        body.model = config.modelId;
+        if (config.format === "openai-completions" &&
+            config.maxTokensField === "max_completion_tokens" &&
+            body.max_tokens !== undefined) {
+            body.max_completion_tokens = body.max_tokens;
+            delete body.max_tokens;
+        }
+        const headers = new Headers(init.headers);
+        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);
+        return config.fetch(input, {
+            ...init,
+            headers,
+            body: JSON.stringify(body),
+        });
+    };
+    const connection = { baseURL: config.baseURL, apiKey: config.apiKey, fetch };
+    const model = config.format === "anthropic-messages"
+        ? createAnthropic({
+            ...connection,
+            ...(config.auth === "bearer"
+                ? { apiKey: undefined, authToken: config.apiKey }
+                : {}),
+        })(resolveAnthropicModelId(config.modelId))
+        : config.format === "openai-responses"
+            ? createOpenAI(connection).responses(config.modelId)
+            : createOpenAICompatible({
+                ...connection,
+                name: "openaiCompatible",
+                includeUsage: config.includeUsage,
+                transformRequestBody: moveOpenAICompatibleCacheControlToMessageContent,
+            })(config.modelId);
+    function withCacheWrites(usage, raw) {
+        const parsed = usageSchema.safeParse(raw);
+        const write = parsed.success
+            ? (parsed.data.input_tokens_details?.cache_write_tokens ??
+                parsed.data.prompt_tokens_details?.cache_creation_input_tokens)
+            : undefined;
+        if (write === undefined)
+            return usage;
+        return {
+            ...usage,
+            inputTokens: {
+                ...usage.inputTokens,
+                cacheWrite: write,
+                noCache: usage.inputTokens.total === undefined
+                    ? undefined
+                    : Math.max(0, usage.inputTokens.total -
+                        (usage.inputTokens.cacheRead ?? 0) -
+                        write),
+            },
+        };
+    }
+    return wrapLanguageModel({
+        model,
+        modelId: config.modelId,
+        middleware: {
+            transformParams: async ({ params }) => {
+                const overrides = object.parse(params.providerOptions?.[namespace] ?? {});
+                const options = { ...providerDefaults, ...overrides };
+                if (config.format === "openai-responses" &&
+                    options.reasoningEffort !== undefined)
+                    options.forceReasoning ??= true;
+                return {
+                    ...params,
+                    maxOutputTokens: params.maxOutputTokens ?? config.maxOutputTokens,
+                    temperature: params.temperature ?? controls.temperature,
+                    topP: params.topP ?? controls.top_p,
+                    presencePenalty: params.presencePenalty ?? controls.presence_penalty,
+                    frequencyPenalty: params.frequencyPenalty ?? controls.frequency_penalty,
+                    seed: params.seed ?? controls.seed,
+                    providerOptions: { ...params.providerOptions, [namespace]: options },
+                };
+            },
+            wrapGenerate: async ({ doGenerate }) => {
+                const result = await doGenerate();
+                const raw = usageFrameSchema.safeParse(result.response?.body);
+                return {
+                    ...result,
+                    usage: withCacheWrites(result.usage, raw.success ? raw.data.usage : undefined),
+                };
+            },
+            wrapStream: async ({ model: providerModel, params }) => {
+                const result = await providerModel.doStream({
+                    ...params,
+                    includeRawChunks: true,
+                });
+                let rawUsage;
+                return {
+                    ...result,
+                    stream: result.stream.pipeThrough(new TransformStream({
+                        transform(chunk, controller) {
+                            if (chunk.type === "raw") {
+                                const frame = usageFrameSchema.safeParse(chunk.rawValue);
+                                if (frame.success)
+                                    rawUsage =
+                                        frame.data.usage ??
+                                            frame.data.response?.usage ??
+                                            rawUsage;
+                                if (!params.includeRawChunks)
+                                    return;
+                            }
+                            controller.enqueue(chunk.type === "finish"
+                                ? {
+                                    ...chunk,
+                                    usage: withCacheWrites(chunk.usage, rawUsage),
+                                }
+                                : chunk);
+                        },
+                    })),
+                };
+            },
+        },
+    });
+}

package/dist/openai-compatible-cache-control.d.ts

@@ -0,0 +1 @@
+export declare function moveOpenAICompatibleCacheControlToMessageContent(body: Record<string, any>): Record<string, any>;

package/dist/openai-compatible-cache-control.js

@@ -0,0 +1,71 @@
+export function moveOpenAICompatibleCacheControlToMessageContent(body) {
+    if (!Array.isArray(body.messages)) {
+        return body;
+    }
+    return {
+        ...body,
+        messages: body.messages.map(moveMessageCacheControlToContent),
+    };
+}
+function moveMessageCacheControlToContent(message) {
+    if (!message ||
+        typeof message !== "object" ||
+        Array.isArray(message) ||
+        !("cache_control" in message)) {
+        return message;
+    }
+    const { cache_control: cacheControl, content, ...messageWithoutCacheControl } = message;
+    if (cacheControl == null) {
+        return message;
+    }
+    if (typeof content === "string") {
+        return {
+            ...messageWithoutCacheControl,
+            content: [
+                {
+                    cache_control: cacheControl,
+                    text: content,
+                    type: "text",
+                },
+            ],
+        };
+    }
+    if (!Array.isArray(content)) {
+        return message;
+    }
+    if (content.some(hasCacheControl)) {
+        return {
+            ...messageWithoutCacheControl,
+            content,
+        };
+    }
+    const textPartIndex = findLastTextContentPartIndex(content);
+    if (textPartIndex < 0) {
+        return message;
+    }
+    return {
+        ...messageWithoutCacheControl,
+        content: content.map((part, index) => index === textPartIndex
+            ? { ...part, cache_control: cacheControl }
+            : part),
+    };
+}
+function hasCacheControl(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        "cache_control" in value);
+}
+function findLastTextContentPartIndex(content) {
+    for (let index = content.length - 1; index >= 0; index -= 1) {
+        const part = content[index];
+        if (part &&
+            typeof part === "object" &&
+            !Array.isArray(part) &&
+            "type" in part &&
+            part.type === "text") {
+            return index;
+        }
+    }
+    return -1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.260916-alpha.2",
+  "version": "0.1.260917-alpha.0",
   "private": false,
   "homepage": "https://musegea.com/developers",
   "license": "Apache-2.0",
@@ -88,6 +88,10 @@
     "./worker-build-plugins": {
       "types": "./dist/worker-build-plugins.d.ts",
       "import": "./dist/worker-build-plugins.js"
+    },
+    "./catalog-language-model": {
+      "types": "./dist/catalog-language-model.d.ts",
+      "import": "./dist/catalog-language-model.js"
     }
   },
   "publishConfig": {
@@ -100,7 +104,7 @@
     "@ai-sdk/otel": "1.0.9",
     "@ai-sdk/provider": "4.0.1",
     "@ai-sdk/provider-utils": "5.0.2",
-    "@gea-ai/contract": "0.1.260916-alpha.2",
+    "@gea-ai/contract": "0.1.260917-alpha.0",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",