@krak-stack/registry 0.1.2 → 0.1.4

package/dist/services/agent/client/widget.d.ts

@@ -0,0 +1,52 @@
+import { type ReactNode } from "react";
+import type { AgentState, AgentSubmitAction } from "./atom.js";
+import type { AgentReference } from "../schema.js";
+export type AgentWidgetReference<Resource> = AgentReference<Resource> & {
+    readonly icon?: ReactNode;
+    readonly key: string;
+};
+export type AgentWidgetMessages = {
+    approve: string;
+    approvalDestructive: string;
+    approvalDestructiveLabel: string;
+    approvalRequired: string;
+    cancel: string;
+    close: string;
+    copied: string;
+    copy: string;
+    description: string;
+    errorInvalidRequest: string;
+    errorRoundLimit: string;
+    errorStreamFailed: string;
+    errorUnavailable: string;
+    maximize: string;
+    minimize: string;
+    noReferences: string;
+    open: string;
+    placeholder: string;
+    removeContext: string;
+    references: string;
+    restore: string;
+    scrollLatest: string;
+    send: string;
+    stop: string;
+    title: string;
+    toolDenied: string;
+    toolFailed: string;
+    toolRunning: string;
+    toolWorked: (seconds: number) => string;
+    viewLess: string;
+    viewMore: string;
+    welcome: string;
+};
+export declare const agentWidgetMessages: (locale?: "en" | "fr", overrides?: Partial<AgentWidgetMessages>) => AgentWidgetMessages;
+export declare function AgentWidget<Resource = never>({ availableReferences, context, messages: messageOverrides, onInterrupt, onRemoveContext, onReset, onSubmit, state, }: {
+    readonly availableReferences?: ReadonlyArray<AgentWidgetReference<Resource>>;
+    readonly context?: AgentWidgetReference<Resource>;
+    readonly messages?: Partial<AgentWidgetMessages>;
+    readonly onInterrupt: () => void;
+    readonly onRemoveContext?: () => void;
+    readonly onReset: () => void;
+    readonly onSubmit: (action: AgentSubmitAction<Resource>) => void;
+    readonly state: AgentState<Resource>;
+}): import("react").JSX.Element;

package/dist/services/agent/index.d.ts

@@ -0,0 +1,111 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { LanguageModel, Tool, Toolkit } from "effect/unstable/ai";
+import type { AgentAction } from "./schema.js";
+export type AgentStreamOptions<Tools extends Record<string, Tool.Any>> = {
+    readonly action: AgentAction;
+    readonly history?: string;
+    readonly systemPrompt: string;
+    readonly toolkit: Toolkit.WithHandler<Tools>;
+};
+declare const AgentHistoryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AgentHistoryError";
+} & Readonly<A>;
+declare class AgentHistoryError extends AgentHistoryError_base {
+}
+declare const AgentService_base: Context.ServiceClass<AgentService, "AgentService", {
+    stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"message-start">;
+        readonly messageId: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"text-delta">;
+        readonly messageId: import("effect/Schema").String;
+        readonly delta: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"tool-call">;
+        readonly messageId: import("effect/Schema").String;
+        readonly toolCallId: import("effect/Schema").String;
+        readonly name: import("effect/Schema").String;
+        readonly input: import("effect/Schema").Unknown;
+        readonly metadata: import("effect/Schema").Struct<{
+            readonly title: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly destructive: import("effect/Schema").Boolean;
+        }>;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"tool-result">;
+        readonly toolCallId: import("effect/Schema").String;
+        readonly name: import("effect/Schema").String;
+        readonly isFailure: import("effect/Schema").Boolean;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"approval-required">;
+        readonly approvalId: import("effect/Schema").String;
+        readonly toolCallId: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"history">;
+        readonly value: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"finish">;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literal<"error">;
+        readonly code: import("effect/Schema").Literals<readonly ["unavailable", "invalid-request", "round-limit", "stream-failed"]>;
+    }, "Type"> | {
+        type: "history";
+        value: string;
+    } | {
+        type: "error";
+        code: "stream-failed";
+    } | {
+        type: "finish";
+    }, never, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | import("effect/SchemaError").SchemaError, LanguageModel.LanguageModel>;
+}> & {
+    readonly make: Effect.Effect<{
+        stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"message-start">;
+            readonly messageId: import("effect/Schema").String;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"text-delta">;
+            readonly messageId: import("effect/Schema").String;
+            readonly delta: import("effect/Schema").String;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"tool-call">;
+            readonly messageId: import("effect/Schema").String;
+            readonly toolCallId: import("effect/Schema").String;
+            readonly name: import("effect/Schema").String;
+            readonly input: import("effect/Schema").Unknown;
+            readonly metadata: import("effect/Schema").Struct<{
+                readonly title: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly destructive: import("effect/Schema").Boolean;
+            }>;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"tool-result">;
+            readonly toolCallId: import("effect/Schema").String;
+            readonly name: import("effect/Schema").String;
+            readonly isFailure: import("effect/Schema").Boolean;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"approval-required">;
+            readonly approvalId: import("effect/Schema").String;
+            readonly toolCallId: import("effect/Schema").String;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"history">;
+            readonly value: import("effect/Schema").String;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"finish">;
+        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literal<"error">;
+            readonly code: import("effect/Schema").Literals<readonly ["unavailable", "invalid-request", "round-limit", "stream-failed"]>;
+        }, "Type"> | {
+            type: "history";
+            value: string;
+        } | {
+            type: "error";
+            code: "stream-failed";
+        } | {
+            type: "finish";
+        }, never, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | import("effect/SchemaError").SchemaError, LanguageModel.LanguageModel>;
+    }, never, never>;
+};
+export declare class AgentService extends AgentService_base {
+    static readonly layer: Layer.Layer<AgentService, never, never>;
+}
+export {};

package/dist/services/agent/index.js

@@ -0,0 +1,190 @@
+// ../../src/services/agent/index.ts
+import { Context, Data, Effect, Layer, Option, Ref, Stream } from "effect";
+import {
+  Chat,
+  LanguageModel,
+  Prompt,
+  Tool
+} from "effect/unstable/ai";
+
+class AgentHistoryError extends Data.TaggedError("AgentHistoryError") {
+}
+
+class AgentService extends Context.Service()("AgentService", {
+  make: Effect.gen(function* () {
+    const streamErrorDetails = (error) => {
+      if (!error || typeof error !== "object") {
+        return { error: String(error) };
+      }
+      const message = Reflect.get(error, "message");
+      const reason = Reflect.get(error, "reason");
+      const status = Reflect.get(error, "status");
+      const tag = Reflect.get(error, "_tag");
+      return {
+        ...typeof message === "string" ? { message } : {},
+        ...typeof reason === "string" ? { reason } : {},
+        ...typeof status === "number" ? { status } : {},
+        ...typeof tag === "string" ? { tag } : {}
+      };
+    };
+    const eventsForPart = ({
+      messageId,
+      part,
+      toolkit
+    }) => {
+      switch (part.type) {
+        case "text-delta":
+          return [{ type: "text-delta", messageId, delta: part.delta }];
+        case "tool-call": {
+          const tool = toolkit.tools[part.name];
+          const title = tool ? Option.getOrUndefined(Context.getOption(tool.annotations, Tool.Title)) : undefined;
+          return [
+            {
+              type: "tool-call",
+              messageId,
+              toolCallId: part.id,
+              name: part.name,
+              input: part.params,
+              metadata: {
+                ...title ? { title } : {},
+                ...tool?.description ? { description: tool.description } : {},
+                destructive: tool ? Context.get(tool.annotations, Tool.Destructive) : false
+              }
+            }
+          ];
+        }
+        case "tool-result":
+          return [
+            {
+              type: "tool-result",
+              toolCallId: part.id,
+              name: part.name,
+              isFailure: part.isFailure
+            }
+          ];
+        case "tool-approval-request":
+          return [
+            {
+              type: "approval-required",
+              approvalId: part.approvalId,
+              toolCallId: part.toolCallId
+            }
+          ];
+        case "error":
+          return [{ type: "error", code: "stream-failed" }];
+        default:
+          return [];
+      }
+    };
+    const agentRounds = ({
+      conversation,
+      messageId,
+      prompt,
+      round,
+      toolkit
+    }) => Stream.suspend(() => {
+      let hasApproval = false;
+      const toolCallIds = new Set;
+      const toolResultIds = new Set;
+      const current = conversation.streamText({ prompt, toolkit }).pipe(Stream.tap((part) => Effect.sync(() => {
+        if (part.type === "tool-call" && part.providerExecuted !== true) {
+          toolCallIds.add(part.id);
+        }
+        if (part.type === "tool-result" && part.providerExecuted !== true && part.preliminary !== true) {
+          toolResultIds.add(part.id);
+        }
+        if (part.type === "tool-approval-request")
+          hasApproval = true;
+      })), Stream.tap((part) => part.type === "error" ? Effect.logError("Agent model response failed", streamErrorDetails(part.error)) : Effect.void), Stream.flatMap((part) => Stream.fromIterable(eventsForPart({ messageId, part, toolkit }))));
+      const continuation = Stream.suspend(() => {
+        if (hasApproval || toolCallIds.size === 0)
+          return Stream.empty;
+        if (![...toolCallIds].every((id) => toolResultIds.has(id))) {
+          return Stream.succeed({
+            type: "error",
+            code: "stream-failed"
+          });
+        }
+        if (round >= 5) {
+          return Stream.succeed({
+            type: "error",
+            code: "round-limit"
+          });
+        }
+        return agentRounds({
+          conversation,
+          messageId,
+          prompt: [],
+          round: round + 1,
+          toolkit
+        });
+      });
+      return Stream.concat(current, continuation);
+    });
+    const appendApproval = Effect.fn("AgentService.appendApproval")(function* (conversation, action) {
+      const history = yield* Ref.get(conversation.history);
+      let pendingToolCallId;
+      const respondedApprovalIds = new Set;
+      const resolvedToolCallIds = new Set;
+      for (const message of history.content) {
+        for (const part of message.content) {
+          if (typeof part === "string")
+            continue;
+          if (part.type === "tool-approval-request" && part.approvalId === action.approvalId) {
+            pendingToolCallId = part.toolCallId;
+          }
+          if (part.type === "tool-approval-response") {
+            respondedApprovalIds.add(part.approvalId);
+          }
+          if (part.type === "tool-result") {
+            resolvedToolCallIds.add(part.id);
+          }
+        }
+      }
+      if (!pendingToolCallId || respondedApprovalIds.has(action.approvalId) || resolvedToolCallIds.has(pendingToolCallId)) {
+        return yield* new AgentHistoryError;
+      }
+      yield* Ref.set(conversation.history, Prompt.concat(history, [
+        Prompt.toolMessage({
+          content: [
+            Prompt.toolApprovalResponsePart({
+              approvalId: action.approvalId,
+              approved: action.approved
+            })
+          ]
+        })
+      ]));
+    });
+    const stream = Effect.fn("AgentService.stream")(function* ({ action, history, systemPrompt, toolkit }) {
+      const model = yield* LanguageModel.LanguageModel;
+      const messageId = crypto.randomUUID();
+      const conversation = history ? yield* Chat.fromJson(history) : yield* Chat.fromPrompt([{ role: "system", content: systemPrompt }]);
+      yield* Ref.update(conversation.history, Prompt.setSystem(systemPrompt));
+      if (action.type === "approval") {
+        yield* appendApproval(conversation, action);
+      }
+      const rounds = agentRounds({
+        conversation,
+        messageId,
+        prompt: action.type === "message" ? action.text : [],
+        round: 1,
+        toolkit
+      });
+      const complete = Stream.fromEffect(Effect.gen(function* () {
+        const history2 = yield* conversation.exportJson;
+        return { type: "history", value: history2 };
+      })).pipe(Stream.concat(Stream.succeed({ type: "finish" })));
+      const response = Stream.concat(rounds, complete).pipe(Stream.provideService(LanguageModel.LanguageModel, model), Stream.catch((error) => Stream.fromEffect(Effect.logError("Agent stream failed", streamErrorDetails(error))).pipe(Stream.drain, Stream.concat(Stream.make({
+        type: "error",
+        code: "stream-failed"
+      }, { type: "finish" })))));
+      return Stream.concat(Stream.succeed({ type: "message-start", messageId }), response);
+    });
+    return { stream };
+  })
+}) {
+  static layer = Layer.effect(this, this.make);
+}
+export {
+  AgentService
+};

package/dist/services/agent/schema.d.ts

@@ -0,0 +1,161 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+export declare const AGENT_REFERENCE_LIMIT = 20;
+export type AgentReference<Resource> = {
+    readonly label: string;
+    readonly resource: Resource;
+};
+export declare const makeAgentReference: <const Resource extends Schema.Top>(resource: Resource) => Schema.Struct<{
+    readonly label: Schema.String;
+    readonly resource: Resource;
+}>;
+export type AgentAction<Resource = never> = {
+    readonly type: "message";
+    readonly text: string;
+    readonly references?: ReadonlyArray<AgentReference<Resource>>;
+} | {
+    readonly type: "approval";
+    readonly approvalId: string;
+    readonly approved: boolean;
+};
+export declare const AgentToolMetadata: Schema.Struct<{
+    readonly title: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly destructive: Schema.Boolean;
+}>;
+export declare const AgentEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"message-start">;
+    readonly messageId: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"text-delta">;
+    readonly messageId: Schema.String;
+    readonly delta: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly messageId: Schema.String;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly metadata: Schema.Struct<{
+        readonly title: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly destructive: Schema.Boolean;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-result">;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly isFailure: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"approval-required">;
+    readonly approvalId: Schema.String;
+    readonly toolCallId: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"history">;
+    readonly value: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"finish">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly code: Schema.Literals<readonly ["unavailable", "invalid-request", "round-limit", "stream-failed"]>;
+}>]>;
+export type AgentEvent = typeof AgentEvent.Type;
+export type AgentErrorCode = Extract<AgentEvent, {
+    readonly type: "error";
+}>["code"];
+export type AgentRequest<Resource> = {
+    readonly action: AgentAction<Resource>;
+    readonly context?: AgentReference<Resource>;
+    readonly history?: string;
+};
+export declare const makeAgentApiGroup: <const Resource extends Schema.Top>(resource: Resource) => HttpApiGroup.HttpApiGroup<"agent", HttpApiEndpoint.HttpApiEndpoint<"stream", "POST", "/agent", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"message">;
+        readonly text: Schema.String;
+        readonly references: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly resource: Resource;
+        }>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"approval">;
+        readonly approvalId: Schema.NonEmptyString;
+        readonly approved: Schema.Boolean;
+    }>]>;
+    readonly context: Schema.optional<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly resource: Resource;
+    }>>;
+    readonly history: Schema.optional<Schema.String>;
+}>>, never, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"message-start">;
+    readonly messageId: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"text-delta">;
+    readonly messageId: Schema.String;
+    readonly delta: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly messageId: Schema.String;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly metadata: Schema.Struct<{
+        readonly title: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly destructive: Schema.Boolean;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool-result">;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly isFailure: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"approval-required">;
+    readonly approvalId: Schema.String;
+    readonly toolCallId: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"history">;
+    readonly value: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"finish">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly code: Schema.Literals<readonly ["unavailable", "invalid-request", "round-limit", "stream-failed"]>;
+}>]>>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["unavailable", "stream-failed"]>;
+}>, Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"message-start">;
+    readonly messageId: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"text-delta">;
+    readonly messageId: Schema.String;
+    readonly delta: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"tool-call">;
+    readonly messageId: Schema.String;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly metadata: Schema.Struct<{
+        readonly title: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly destructive: Schema.Boolean;
+    }>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"tool-result">;
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly isFailure: Schema.Boolean;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"approval-required">;
+    readonly approvalId: Schema.String;
+    readonly toolCallId: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"history">;
+    readonly value: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"finish">;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"error">;
+    readonly code: Schema.Literals<readonly ["unavailable", "invalid-request", "round-limit", "stream-failed"]>;
+}, "Type">>, Schema.toCodecJson<typeof HttpApiError.BadRequest | typeof HttpApiError.Unauthorized | typeof HttpApiError.Forbidden | typeof HttpApiError.InternalServerError>, never, never>, false>;

package/dist/services/agent/schema.js

@@ -0,0 +1,135 @@
+// ../../src/services/agent/schema.ts
+import { Schema } from "effect";
+import {
+  HttpApiEndpoint,
+  HttpApiError,
+  HttpApiGroup,
+  HttpApiSchema,
+  OpenApi
+} from "effect/unstable/httpapi";
+var AgentMessageText = Schema.String.check(Schema.isLengthBetween(1, 4000)).annotate({
+  identifier: "AgentMessageText",
+  title: "Agent message",
+  description: "A user message sent to the agent."
+});
+var AgentReferenceLabel = Schema.String.check(Schema.isLengthBetween(1, 500));
+var AGENT_REFERENCE_LIMIT = 20;
+var makeAgentReference = (resource) => Schema.Struct({
+  label: AgentReferenceLabel,
+  resource
+}).annotate({
+  identifier: "AgentReference",
+  title: "Agent reference",
+  description: "A resource referenced by an agent message."
+});
+var makeAgentAction = (resource) => Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("message"),
+    text: AgentMessageText,
+    references: Schema.optional(Schema.Array(makeAgentReference(resource)).check(Schema.isMaxLength(AGENT_REFERENCE_LIMIT)))
+  }),
+  Schema.Struct({
+    type: Schema.Literal("approval"),
+    approvalId: Schema.NonEmptyString,
+    approved: Schema.Boolean
+  })
+]).annotate({
+  identifier: "AgentAction",
+  title: "Agent action",
+  description: "A message with optional references or a tool approval response."
+});
+var AgentToolMetadata = Schema.Struct({
+  title: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  destructive: Schema.Boolean
+}).annotate({ identifier: "AgentToolMetadata" });
+var AgentEvent = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("message-start"),
+    messageId: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("text-delta"),
+    messageId: Schema.String,
+    delta: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("tool-call"),
+    messageId: Schema.String,
+    toolCallId: Schema.String,
+    name: Schema.String,
+    input: Schema.Unknown,
+    metadata: AgentToolMetadata
+  }),
+  Schema.Struct({
+    type: Schema.Literal("tool-result"),
+    toolCallId: Schema.String,
+    name: Schema.String,
+    isFailure: Schema.Boolean
+  }),
+  Schema.Struct({
+    type: Schema.Literal("approval-required"),
+    approvalId: Schema.String,
+    toolCallId: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("history"),
+    value: Schema.String
+  }),
+  Schema.Struct({ type: Schema.Literal("finish") }),
+  Schema.Struct({
+    type: Schema.Literal("error"),
+    code: Schema.Literals([
+      "unavailable",
+      "invalid-request",
+      "round-limit",
+      "stream-failed"
+    ])
+  })
+]).annotate({
+  identifier: "AgentEvent",
+  title: "Agent stream event",
+  description: "An event emitted by the agent endpoint."
+});
+var AgentStreamError = Schema.Struct({
+  code: Schema.Literals(["unavailable", "stream-failed"])
+}).annotate({
+  identifier: "AgentStreamError",
+  title: "Agent stream error",
+  description: "A recoverable agent stream failure."
+});
+var makeAgentApiGroup = (resource) => {
+  const AgentAction = makeAgentAction(resource);
+  const AgentRequest = Schema.Struct({
+    action: AgentAction,
+    context: Schema.optional(makeAgentReference(resource)),
+    history: Schema.optional(Schema.String.check(Schema.isMaxLength(500000)))
+  }).annotate({
+    identifier: "AgentRequest",
+    title: "Agent request",
+    description: "An authenticated agent request."
+  });
+  return HttpApiGroup.make("agent").add(HttpApiEndpoint.post("stream", "/agent", {
+    payload: AgentRequest,
+    success: HttpApiSchema.StreamSse({
+      data: AgentEvent,
+      error: AgentStreamError
+    }),
+    error: [
+      HttpApiError.BadRequest,
+      HttpApiError.Unauthorized,
+      HttpApiError.Forbidden,
+      HttpApiError.InternalServerError
+    ]
+  }).annotateMerge(OpenApi.annotations({
+    summary: "Stream agent",
+    description: "Streams an AI agent response for the current session."
+  })));
+};
+export {
+  makeAgentReference,
+  makeAgentApiGroup,
+  AgentToolMetadata,
+  AgentEvent,
+  AGENT_REFERENCE_LIMIT
+};