@krak-stack/registry 0.1.13 → 0.1.15

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

@@ -1,4 +1,4 @@
-import { Effect, Stream } from "effect";
+import { Effect, Option, Stream } from "effect";
 import { Atom, Reactivity } from "effect/unstable/reactivity";
 import type { AgentErrorCode, AgentEvent, AgentReference, AgentRequest } from "../schema.js";
 export type AgentToolStatus = "running" | "approval-required" | "approved" | "denied" | "completed" | "failed";
@@ -37,9 +37,9 @@ export type AgentState<Resource = never> = {
 };
 export declare const initialAgentState: AgentState<never>;
 export declare const reduceAgentEvent: <Resource>(state: AgentState<Resource>, event: AgentEvent) => AgentState<Resource>;
-export type AgentAtomsConfig<Resource> = {
-    readonly stream: (get: Atom.FnContext, request: AgentRequest<Resource>) => Effect.Effect<Stream.Stream<AgentEvent, unknown, Reactivity.Reactivity>, unknown>;
-    readonly errorCode?: (error: unknown) => AgentErrorCode;
+export type AgentAtomsConfig<Resource, Failure = ErrorOptions["cause"]> = {
+    readonly stream: (get: Atom.FnContext, request: AgentRequest<Resource>) => Effect.Effect<Stream.Stream<AgentEvent, Failure, Reactivity.Reactivity>, Failure>;
+    readonly errorCode?: (error: Failure) => AgentErrorCode;
     readonly reactivityKeys?: ReadonlyArray<unknown>;
     readonly runtime?: Atom.AtomRuntime<never>;
 };
@@ -48,9 +48,9 @@ export type AgentSubmitInput<Resource> = {
     readonly context?: AgentConversationContext<Resource>;
     readonly scope: string;
 };
-export declare const makeAgentAtoms: <Resource>({ errorCode, reactivityKeys, runtime, stream, }: AgentAtomsConfig<Resource>) => {
-    readonly removeContext: Atom.Writable<import("effect/Option").Option<void>, string>;
-    readonly reset: Atom.Writable<import("effect/Option").Option<void>, string>;
+export declare const makeAgentAtoms: <Resource, Failure = unknown>({ errorCode, reactivityKeys, runtime, stream, }: AgentAtomsConfig<Resource, Failure>) => {
+    readonly removeContext: Atom.Writable<Option.Option<void>, string>;
+    readonly reset: Atom.Writable<Option.Option<void>, string>;
     readonly state: (arg: string) => Atom.Writable<AgentState<Resource>, AgentState<Resource>>;
     readonly submit: Atom.AtomResultFn<AgentSubmitInput<Resource>, void, never>;
 };

package/dist/services/agent/client/index.js

@@ -1,5 +1,5 @@
 // ../../src/services/agent/client/atom.ts
-import { Effect, Layer, Stream } from "effect";
+import { Effect, Layer, Option, Schema, Stream } from "effect";
 import { Atom } from "effect/unstable/reactivity";
 var initialAgentState = {
   context: undefined,
@@ -64,12 +64,15 @@ var reduceAgentEvent = (state, event) => {
       return state;
   }
 };
+var AgentError = Schema.Struct({
+  code: Schema.Literals(["stream-failed", "unavailable"])
+}).annotate({ identifier: "AgentError" });
 var defaultErrorCode = (error) => {
-  if (error && typeof error === "object") {
-    const code = Reflect.get(error, "code");
-    if (code === "stream-failed" || code === "unavailable")
-      return code;
-  }
+  const failure = Schema.decodeUnknownOption(AgentError)(error);
+  if (Option.isNone(failure))
+    return "unavailable";
+  if (failure.value.code === "stream-failed")
+    return "stream-failed";
   return "unavailable";
 };
 var makeAgentAtoms = ({
@@ -628,8 +631,9 @@ function InputGroupAddon({
     "data-align": align,
     className: cn(inputGroupAddonVariants({ align }), className),
     onClick: (event) => {
-      if (event.target.closest("button"))
+      if (event.target instanceof HTMLElement && event.target.closest("button")) {
         return;
+      }
       event.currentTarget.parentElement?.querySelector("input")?.focus();
     },
     ...props
@@ -1346,7 +1350,7 @@ function isCustomStrategy(strategy2) {
 }
 
 // ../../src/services/agent/schema.ts
-import { Schema } from "effect";
+import { Schema as Schema2 } from "effect";
 import {
   HttpApiEndpoint,
   HttpApiError,
@@ -1354,63 +1358,63 @@ import {
   HttpApiSchema,
   OpenApi
 } from "effect/unstable/httpapi";
-var AgentMessageText = Schema.String.check(Schema.isLengthBetween(1, 4000)).annotate({
+var AgentMessageText = Schema2.String.check(Schema2.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 AgentReferenceLabel = Schema2.String.check(Schema2.isLengthBetween(1, 500));
 var AGENT_REFERENCE_LIMIT = 20;
-var AgentToolMetadata = Schema.Struct({
-  title: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  destructive: Schema.Boolean
+var AgentToolMetadata = Schema2.Struct({
+  title: Schema2.optional(Schema2.String),
+  description: Schema2.optional(Schema2.String),
+  destructive: Schema2.Boolean
 }).annotate({ identifier: "AgentToolMetadata" });
-var AgentEvent = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("message-start"),
-    messageId: Schema.String
+var AgentEvent = Schema2.Union([
+  Schema2.Struct({
+    type: Schema2.Literal("message-start"),
+    messageId: Schema2.String
   }),
-  Schema.Struct({
-    type: Schema.Literal("text-delta"),
-    messageId: Schema.String,
-    delta: Schema.String
+  Schema2.Struct({
+    type: Schema2.Literal("text-delta"),
+    messageId: Schema2.String,
+    delta: Schema2.String
   }),
-  Schema.Struct({
-    type: Schema.Literal("tool-call"),
-    messageId: Schema.String,
-    toolCallId: Schema.String,
-    name: Schema.String,
-    input: Schema.Unknown,
+  Schema2.Struct({
+    type: Schema2.Literal("tool-call"),
+    messageId: Schema2.String,
+    toolCallId: Schema2.String,
+    name: Schema2.String,
+    input: Schema2.Unknown,
     metadata: AgentToolMetadata
   }),
-  Schema.Struct({
-    type: Schema.Literal("tool-result"),
-    toolCallId: Schema.String,
-    name: Schema.String,
-    isFailure: Schema.Boolean
+  Schema2.Struct({
+    type: Schema2.Literal("tool-result"),
+    toolCallId: Schema2.String,
+    name: Schema2.String,
+    isFailure: Schema2.Boolean
   }),
-  Schema.Struct({
-    type: Schema.Literal("approval-required"),
-    approvalId: Schema.String,
-    toolCallId: Schema.String
+  Schema2.Struct({
+    type: Schema2.Literal("approval-required"),
+    approvalId: Schema2.String,
+    toolCallId: Schema2.String
   }),
-  Schema.Struct({
-    type: Schema.Literal("history"),
-    value: Schema.String
+  Schema2.Struct({
+    type: Schema2.Literal("history"),
+    value: Schema2.String
   }),
-  Schema.Struct({ type: Schema.Literal("finish") }),
-  Schema.Struct({
-    type: Schema.Literal("error"),
-    code: Schema.Literals(["unavailable", "invalid-request", "stream-failed"])
+  Schema2.Struct({ type: Schema2.Literal("finish") }),
+  Schema2.Struct({
+    type: Schema2.Literal("error"),
+    code: Schema2.Literals(["unavailable", "invalid-request", "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"])
+var AgentStreamError = Schema2.Struct({
+  code: Schema2.Literals(["unavailable", "stream-failed"])
 }).annotate({
   identifier: "AgentStreamError",
   title: "Agent stream error",
@@ -1523,7 +1527,30 @@ var highlightedInput = (input, references) => {
     children: part
   }, `${part}:${index}`) : part);
 };
-var referenceSearchQuery = (input) => input.match(/(?:^|\s)@([^@\n]*)$/)?.[1].trimEnd();
+var referenceSearchAtCursor = (input, cursor) => {
+  const beforeCursor = input.slice(0, cursor);
+  const match = beforeCursor.match(/(?:^|\s)@([^@\n]*)$/);
+  if (!match)
+    return;
+  return {
+    start: beforeCursor.lastIndexOf("@"),
+    end: cursor,
+    query: match[1].trimEnd()
+  };
+};
+var insertReferenceMention = (input, search, label) => {
+  const suffix = input.slice(search.end);
+  const mention = `@${label}`;
+  const separator = /^[ \t]/.test(suffix) ? "" : " ";
+  return {
+    input: `${input.slice(0, search.start)}${mention}${separator}${suffix}`,
+    cursor: search.start + mention.length + 1
+  };
+};
+var completesSelectedReference = (input, search, references) => {
+  const searchText = input.slice(search.start + 1, search.end);
+  return references.some(({ label }) => searchText.startsWith(`${label} `));
+};
 var ToolLabel = ({
   description,
   label
@@ -1869,14 +1896,16 @@ function AgentWidget({
   const [maximized, setMaximized] = useState(false);
   const [referencePickerOpen, setReferencePickerOpen] = useState(false);
   const [activeReferenceKey, setActiveReferenceKey] = useState("");
+  const [activeReferenceSearch, setActiveReferenceSearch] = useState();
   const [input, setInput] = useState("");
+  const inputRef = useRef(null);
   const inputOverlayRef = useRef(null);
   const [references, setReferences] = useState([]);
   const activeContext = state.contextLocked ? state.context ? {
     ...state.context,
     icon: availableReferences.find(({ key }) => key === state.context?.key)?.icon
   } : undefined : context;
-  const referenceQuery = referenceSearchQuery(input);
+  const referenceQuery = activeReferenceSearch?.query;
   const selectedKeys = new Set(references.map(({ key }) => key));
   const selectedLabels = new Set(references.map(({ label }) => label));
   const selectableReferences = availableReferences.filter((reference) => references.length < AGENT_REFERENCE_LIMIT && reference.key !== activeContext?.key && !selectedKeys.has(reference.key) && !selectedLabels.has(reference.label));
@@ -1890,17 +1919,15 @@ function AgentWidget({
       return;
     setInput("");
     setReferences([]);
+    setActiveReferenceSearch(undefined);
     setReferencePickerOpen(false);
-    onSubmit({
+    const messageReferences = references.length > 0 ? references.map(({ label, resource }) => ({ label, resource })) : undefined;
+    const action = {
       type: "message",
       text,
-      ...references.length > 0 ? {
-        references: references.map(({ label, resource }) => ({
-          label,
-          resource
-        }))
-      } : {}
-    });
+      references: messageReferences
+    };
+    onSubmit(action);
   };
   const respondToApproval = (tool, approved) => {
     if (!tool.approvalId || state.pending)
@@ -1913,15 +1940,24 @@ function AgentWidget({
     });
   };
   const selectReference = (reference) => {
+    if (!activeReferenceSearch)
+      return;
+    const replacement = insertReferenceMention(input, activeReferenceSearch, reference.label);
     setReferences((current) => [...current, reference]);
-    setInput((current) => current.replace(/@[^@\n]*$/, `@${reference.label}`));
+    setInput(replacement.input);
+    setActiveReferenceSearch(undefined);
     setReferencePickerOpen(false);
+    requestAnimationFrame(() => {
+      inputRef.current?.focus();
+      inputRef.current?.setSelectionRange(replacement.cursor, replacement.cursor);
+    });
   };
   const clearConversation = () => {
     onInterrupt();
     onReset();
     setInput("");
     setReferences([]);
+    setActiveReferenceSearch(undefined);
     setReferencePickerOpen(false);
   };
   const handleOpenChange = (nextOpen) => {
@@ -2115,6 +2151,7 @@ function AgentWidget({
                           /* @__PURE__ */ jsx17(PopoverTrigger, {
                             id: referenceInputId,
                             render: /* @__PURE__ */ jsx17(InputGroupTextarea, {
+                              ref: inputRef,
                               className: "caret-foreground selection:bg-primary selection:text-primary-foreground relative max-h-32 w-full [scrollbar-width:thin] [scrollbar-color:var(--border)_transparent] [scrollbar-gutter:stable] overflow-y-auto overscroll-contain text-left text-transparent",
                               value: input,
                               placeholder: labels.placeholder,
@@ -2133,11 +2170,12 @@ function AgentWidget({
                               },
                               onChange: (event) => {
                                 const value = event.target.value;
+                                const candidate = referenceSearchAtCursor(value, event.currentTarget.selectionStart);
+                                const search = candidate && !completesSelectedReference(value, candidate, references) ? candidate : undefined;
                                 setInput(value);
+                                setActiveReferenceSearch(search);
                                 setReferences((current) => current.filter(({ label }) => hasReferenceMention(value, label)));
-                                const query = referenceSearchQuery(value);
-                                const startsReferenceQuery = query !== undefined && value.lastIndexOf("@") > input.lastIndexOf("@");
-                                setReferencePickerOpen((current) => current || startsReferenceQuery && selectableReferences.length > 0);
+                                setReferencePickerOpen(search !== undefined && selectableReferences.length > 0);
                               },
                               onKeyDown: (event) => {
                                 if (event.key === "Escape" && referencePickerOpen) {
@@ -2179,7 +2217,7 @@ function AgentWidget({
                                   /* @__PURE__ */ jsx17(CommandEmpty, {
                                     children: labels.noReferences
                                   }),
-                                  /* @__PURE__ */ jsx17(CommandGroup, {
+                                  matchingReferences.length > 0 ? /* @__PURE__ */ jsx17(CommandGroup, {
                                     heading: labels.references,
                                     children: matchingReferences.map((reference, index) => /* @__PURE__ */ jsxs5(CommandItem, {
                                       id: `${referenceInputId}-reference-${index}`,
@@ -2193,7 +2231,7 @@ function AgentWidget({
                                         })
                                       ]
                                     }, reference.key))
-                                  })
+                                  }) : null
                                 ]
                               })
                             })

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

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Stream } from "effect";
+import { Context, Effect, Layer, Schema, 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>> = {
@@ -13,41 +13,41 @@ declare const AgentHistoryError_base: new <A extends Record<string, any> = {}>(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;
+    stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<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"> | 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", "stream-failed"]>;
+    }, "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", "stream-failed"]>;
     }, "Type"> | {
         type: "history";
         value: string;
@@ -56,44 +56,44 @@ declare const AgentService_base: Context.ServiceClass<AgentService, "AgentServic
         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, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | Schema.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;
+        stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<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"> | 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", "stream-failed"]>;
+        }, "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", "stream-failed"]>;
         }, "Type"> | {
             type: "history";
             value: string;
@@ -102,7 +102,7 @@ declare const AgentService_base: Context.ServiceClass<AgentService, "AgentServic
             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, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | Schema.SchemaError, LanguageModel.LanguageModel>;
     }, never, never>;
 };
 export declare class AgentService extends AgentService_base {

package/dist/services/agent/index.js

@@ -1,5 +1,14 @@
 // ../../src/services/agent/index.ts
-import { Context, Data, Effect, Layer, Option, Ref, Stream } from "effect";
+import {
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Option,
+  Ref,
+  Schema,
+  Stream
+} from "effect";
 import {
   Chat,
   LanguageModel,
@@ -9,23 +18,30 @@ import {
 
 class AgentHistoryError extends Data.TaggedError("AgentHistoryError") {
 }
+var AgentStreamErrorDetails = Schema.Struct({
+  message: Schema.optional(Schema.String),
+  reason: Schema.optional(Schema.String),
+  status: Schema.optional(Schema.Number),
+  _tag: Schema.optional(Schema.String)
+}).annotate({ identifier: "AgentStreamErrorDetails" });
+var decodeAgentStreamErrorDetails = Schema.decodeUnknownOption(AgentStreamErrorDetails);
 
 class AgentService extends Context.Service()("AgentService", {
   make: Effect.gen(function* () {
     const streamErrorDetails = (error) => {
-      if (!error || typeof error !== "object") {
+      const details = Option.getOrUndefined(decodeAgentStreamErrorDetails(error));
+      if (!details)
         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 result = {};
+      if (details.message)
+        result.message = details.message;
+      if (details.reason)
+        result.reason = details.reason;
+      if (details.status !== undefined)
+        result.status = details.status;
+      if (details._tag)
+        result.tag = details._tag;
+      return result;
     };
     const eventsForPart = ({
       messageId,
@@ -45,11 +61,14 @@ class AgentService extends Context.Service()("AgentService", {
               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
-              }
+              metadata: (() => {
+                const metadata = {
+                  destructive: tool ? Context.get(tool.annotations, Tool.Destructive) : false,
+                  title,
+                  description: tool?.description
+                };
+                return metadata;
+              })()
             }
           ];
         }
@@ -120,7 +139,7 @@ class AgentService extends Context.Service()("AgentService", {
       const resolvedToolCallIds = new Set;
       for (const message of history.content) {
         for (const part of message.content) {
-          if (typeof part === "string")
+          if (Schema.is(Schema.String)(part))
             continue;
           if (part.type === "tool-approval-request" && part.approvalId === action.approvalId) {
             pendingToolCallId = part.toolCallId;

package/dist/services/notification/channels/index.d.ts

@@ -1,22 +1,24 @@
 import { Context, Effect, Layer } from "effect";
+import type { Json } from "effect/Schema";
 import { NotificationSendError } from "../schema.js";
 export interface NotificationChannels {
 }
-export type NotificationMessage = keyof NotificationChannels extends never ? Record<string, unknown> : Partial<{
+export type NotificationMessage<FallbackPayload = Json> = keyof NotificationChannels extends never ? Record<string, FallbackPayload> : Partial<{
     readonly [Key in keyof NotificationChannels]: NotificationChannels[Key];
 }>;
-export interface NotificationChannelShape<Key extends string = string, Payload = unknown> {
+export interface NotificationChannel<Key extends string = string, Payload = Json> {
     readonly key: Key;
-    readonly send: (payload: unknown, message: NotificationMessage) => Effect.Effect<void, NotificationSendError>;
+    readonly send: (payload: Payload, message: NotificationMessage) => Effect.Effect<void, NotificationSendError>;
     readonly payload?: Payload;
 }
-export interface NotificationChannelRegistryShape {
-    readonly channels: ReadonlyArray<NotificationChannelShape>;
+export interface NotificationChannelRegistryService {
+    readonly channels: ReadonlyArray<NotificationChannel>;
 }
-declare const NotificationChannelRegistry_base: Context.ServiceClass<NotificationChannelRegistry, "NotificationChannelRegistry", NotificationChannelRegistryShape>;
+/** @deprecated Use the domain-owned names without the Shape suffix. */
+export { type NotificationChannel as NotificationChannelShape, type NotificationChannelRegistryService as NotificationChannelRegistryShape, };
+declare const NotificationChannelRegistry_base: Context.ServiceClass<NotificationChannelRegistry, "NotificationChannelRegistry", NotificationChannelRegistryService>;
 export declare class NotificationChannelRegistry extends NotificationChannelRegistry_base {
-    static readonly make: (...channels: ReadonlyArray<NotificationChannelShape>) => NotificationChannelRegistryShape;
-    static readonly layer: (channels: ReadonlyArray<NotificationChannelShape>) => Layer.Layer<NotificationChannelRegistry, never, never>;
+    static readonly make: (...channels: ReadonlyArray<NotificationChannel>) => NotificationChannelRegistryService;
+    static readonly layer: (channels: ReadonlyArray<NotificationChannel>) => Layer.Layer<NotificationChannelRegistry, never, never>;
     static readonly emptyLayer: Layer.Layer<NotificationChannelRegistry, never, never>;
 }
-export {};