@gea-ai/agent-sdk 0.1.261014-alpha.0 → 0.1.261016-alpha.0

package/dist/agent-call.d.ts

@@ -1,12 +1,12 @@
 import { z } from "zod";
 import { type AgentWorkerToolInitialization } from "@gea-ai/contract/agent-worker-tools";
 import type { AgentHostBinding } from "./agent-worker.js";
-import type { StudioArtifactScope } from "@gea-ai/contract/studio-artifacts";
+import type { BuilderArtifactScope } from "@gea-ai/contract/builder-artifacts";
 /** Fresh Sessions keep the declared-target rule. A resume only needs sessionId. */
 export declare function workerAgentToolInputSchema(input: {
     agents: NonNullable<AgentWorkerToolInitialization["agents"]>;
     canCopy?: boolean;
-    artifactScope?: StudioArtifactScope;
+    artifactScope?: BuilderArtifactScope;
 }): z.ZodObject<{
     sessionId: z.ZodOptional<z.ZodUUID>;
     target: z.ZodOptional<z.ZodString>;
@@ -33,7 +33,7 @@ export declare function createWorkerAgentTool(input: {
     host: AgentHostBinding;
     runId?: string;
     canCopy?: boolean;
-    artifactScope?: StudioArtifactScope;
+    artifactScope?: BuilderArtifactScope;
 }): ({
     deferLoading?: boolean;
     title?: string;

package/dist/agent-channel-api.js

@@ -27,16 +27,41 @@ export function extractChannelReply(messageValue, responseMessageId) {
         .filter((part) => part.type === "text")
         .map((part) => part.text ?? "")
         .join("");
+    const authorizationUrls = new Set();
     for (const part of message.parts) {
         if (!(part.type.startsWith("tool-") || part.type === "dynamic-tool") ||
             part.state !== "output-available")
             continue;
         const authorization = z
-            .object({ status: z.literal("authorization_required"), url: z.url() })
+            .object({
+            status: z.enum(["authorization_required", "authorization_available"]),
+            url: z.url(),
+        })
             .safeParse(part.output);
-        if (authorization.success && !text.includes(authorization.data.url))
-            text += `${text ? "\n\n" : ""}${authorization.data.url}`;
+        if (authorization.success)
+            authorizationUrls.add(authorization.data.url);
     }
+    if (authorizationUrls.size === 0)
+        return { messageId: responseMessageId, text };
+    const authorizationEndpoints = new Set([...authorizationUrls].map((value) => {
+        const url = new URL(value);
+        return `${url.origin}${url.pathname}`;
+    }));
+    const isRewrittenAuthorizationUrl = (value) => {
+        if (authorizationUrls.has(value) || !URL.canParse(value))
+            return false;
+        const url = new URL(value);
+        return authorizationEndpoints.has(`${url.origin}${url.pathname}`);
+    };
+    // Models can corrupt opaque tickets while copying them. Remove those links
+    // before appending the original tool URLs; never leave a broken link first.
+    text = text
+        .replace(/\[([^\]\n]*)\]\((https?:\/\/[^\s)]+)\)/gu, (link, label, url) => isRewrittenAuthorizationUrl(url) ? label : link)
+        .replace(/https?:\/\/[^\s<>)]+/gu, (url) => isRewrittenAuthorizationUrl(url) ? "" : url)
+        .trim();
+    for (const url of authorizationUrls)
+        if (!text.includes(url))
+            text += `${text ? "\n\n" : ""}${url}`;
     return { messageId: responseMessageId, text };
 }
 /** Channel owns delivery; ordinary Agents API owns admission, execution and history. */

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

@@ -1,5 +1,5 @@
 import { type AgentChannelInvocationContext } from "@gea-ai/contract/agent-channels";
-import { type AgentChannelRuntimeCommand, type AgentChannelRuntimeStart, type AgentChannelJson } from "@gea-ai/contract/agent-channel-runtime";
+import { type AgentChannelRuntimeCommand, type AgentChannelRuntimeEnqueue, type AgentChannelJson } from "@gea-ai/contract/agent-channel-runtime";
 import type { AgentChannelFetchEnvironment } from "./agent-worker.js";
 import type { AnyDefinedChannel, ChannelCapabilities, ChannelInputContext, ChannelRouteContext, ChannelWebSocketRoute } from "./channels/index.js";
 export declare function createChannelCapabilities(environment: AgentChannelFetchEnvironment, signal: AbortSignal): Promise<ChannelCapabilities>;
@@ -15,7 +15,7 @@ export declare function createChannelRouteContext(input: Parameters<typeof creat
 /** Only the retained Worker definition interprets state and executes event/outbound code. */
 export declare function executeChannelBehavior(input: {
     definition: AnyDefinedChannel;
-    command: Exclude<AgentChannelRuntimeCommand, AgentChannelRuntimeStart>;
+    command: Exclude<AgentChannelRuntimeCommand, AgentChannelRuntimeEnqueue>;
     environment: AgentChannelFetchEnvironment;
     signal: AbortSignal;
 }): Promise<{

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

@@ -3,7 +3,7 @@ import { readChannelSessionHistory } from "./agent-channel-api.js";
 import { z } from "zod";
 import { validateUIMessages } from "ai";
 import { createAgentChannelStableId, agentChannelUserIdentitySchema, agentChannelAddressSchema, agentChannelExecutionTargetSchema, } from "@gea-ai/contract/agent-channels";
-import { agentChannelInputSchema, agentChannelEventSchema, agentChannelJournalPageSchema, agentChannelJsonSchema, agentChannelOutboundResultSchema, agentChannelRuntimeProjectionSchema, } from "@gea-ai/contract/agent-channel-runtime";
+import { agentChannelInputSchema, agentChannelOutputInputSchema, agentChannelOutputReceiptSchema, agentChannelEventSchema, agentChannelJournalPageSchema, agentChannelJsonSchema, agentChannelOutboundResultSchema, agentChannelRuntimeProjectionSchema, } from "@gea-ai/contract/agent-channel-runtime";
 import { ChannelInputError } from "./channels/index.js";
 const HOST = "/internal/agent-worker-host/v1/channel";
 const initializationSchema = z.object({
@@ -23,6 +23,8 @@ const sessionSchema = z
 })
     .nullable();
 const receiptSchema = z.object({
+    runId: z.uuid(),
+    inputId: z.string().min(1),
     conversationId: z.string(),
     duplicate: z.boolean(),
     executionTarget: agentChannelExecutionTargetSchema,
@@ -289,6 +291,41 @@ export async function createChannelInputContext(input) {
         from(raw, value, sessionOptions) {
             const identity = agentChannelUserIdentitySchema.parse(value);
             return {
+                async enqueueOutput(key, payload, options) {
+                    if (!input.definition.outbound)
+                        throw new Error("Channel output requires an outbound handler.");
+                    await authorize();
+                    await authorizeUser(identity);
+                    const address = await getAddress(raw, identity.principal, sessionOptions);
+                    const normalized = agentChannelOutputInputSchema.parse({
+                        principal: identity.principal,
+                        authorization: identity.authorization,
+                        operationId: await createAgentChannelStableId("external-event", address.installationId, address.agentKey, address.channelKey, options.operationId),
+                        outbox: {
+                            key,
+                            payload: input.definition.outboundSchema
+                                ? input.definition.outboundSchema.parse(payload)
+                                : payload,
+                        },
+                        ...(input.definition.idempotencyWindowMs
+                            ? { idempotencyWindowMs: input.definition.idempotencyWindowMs }
+                            : {}),
+                    });
+                    return agentChannelOutputReceiptSchema.parse(await addressRequest(input.environment, address, "/v2/ingress", {
+                        address,
+                        channelPath: input.definition.path,
+                        executionTarget: await getExecutionTarget(address),
+                        input: normalized,
+                        ...(input.identity.receiverRevision === undefined
+                            ? {}
+                            : {
+                                receiver: {
+                                    installationId: input.identity.installationId,
+                                    revision: input.identity.receiverRevision,
+                                },
+                            }),
+                    }, input.signal));
+                },
                 async send(message, options) {
                     return send(await getAddress(raw, identity.principal, sessionOptions), identity, message, options);
                 },

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

@@ -1,5 +1,5 @@
 import type { AgentChannelAddressStorage, AgentChannelAddressEnvironment } from "./agent-channel-worker.js";
 /** An accepted operation owns its code target; the address owns only stable session state. */
-export declare function handleCustomChannelAddressRequest(request: Request, storage: AgentChannelAddressStorage, _environment?: AgentChannelAddressEnvironment): Promise<Response>;
+export declare function handleCustomChannelAddressRequest(request: Request, storage: AgentChannelAddressStorage, environment?: AgentChannelAddressEnvironment): Promise<Response>;
 /** Input execution, event projection, and delivery advance independently on durable alarms. */
 export declare function handleCustomChannelAddressAlarm(storage: AgentChannelAddressStorage, environment: AgentChannelAddressEnvironment): Promise<void>;