@ai-ecoverse/slicc-agent 1.2.0 → 2.1.0

package/dist/spectrum/emitter.js

@@ -0,0 +1,20 @@
+class Emitter {
+  #listeners = /* @__PURE__ */ new Map();
+  on(type, listener) {
+    let set = this.#listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(type, set);
+    }
+    set.add(listener);
+    return () => set.delete(listener);
+  }
+  emit(type, detail) {
+    for (const listener of [...this.#listeners.get(type) ?? []])
+      listener(detail);
+  }
+}
+export {
+  Emitter
+};
+//# sourceMappingURL=emitter.js.map

package/dist/spectrum/emitter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/spectrum/emitter.ts"],
+  "sourcesContent": ["type Listener<T> = (detail: T) => void;\n\nexport class Emitter<Events extends object> {\n  readonly #listeners = new Map<keyof Events, Set<Listener<never>>>();\n\n  on<K extends keyof Events>(type: K, listener: Listener<Events[K]>): () => void {\n    let set = this.#listeners.get(type);\n    if (!set) {\n      set = new Set();\n      this.#listeners.set(type, set);\n    }\n    set.add(listener as Listener<never>);\n    return () => set.delete(listener as Listener<never>);\n  }\n\n  emit<K extends keyof Events>(type: K, detail: Events[K]): void {\n    for (const listener of [...(this.#listeners.get(type) ?? [])])\n      (listener as Listener<Events[K]>)(detail);\n  }\n}\n"],
+  "mappings": "AAEO,MAAM,QAA+B;AAAA,EACjC,aAAa,oBAAI,IAAwC;AAAA,EAElE,GAA2B,MAAS,UAA2C;AAC7E,QAAI,MAAM,KAAK,WAAW,IAAI,IAAI;AAClC,QAAI,CAAC,KAAK;AACR,YAAM,oBAAI,IAAI;AACd,WAAK,WAAW,IAAI,MAAM,GAAG;AAAA,IAC/B;AACA,QAAI,IAAI,QAA2B;AACnC,WAAO,MAAM,IAAI,OAAO,QAA2B;AAAA,EACrD;AAAA,EAEA,KAA6B,MAAS,QAAyB;AAC7D,eAAW,YAAY,CAAC,GAAI,KAAK,WAAW,IAAI,IAAI,KAAK,CAAC,CAAE;AAC1D,MAAC,SAAiC,MAAM;AAAA,EAC5C;AACF;",
+  "names": []
+}

package/dist/spectrum/index.js

@@ -0,0 +1,17 @@
+import { AgentAdapter } from "./agent-port.js";
+import { AgentAdapter as AgentAdapter2, CONE } from "./agent-port.js";
+import { assistant, isBusy, queued, textOf, toMessages } from "./messages.js";
+function createAgentModel(connection) {
+  return { agent: new AgentAdapter(connection) };
+}
+export {
+  AgentAdapter2 as AgentAdapter,
+  CONE,
+  assistant,
+  createAgentModel,
+  isBusy,
+  queued,
+  textOf,
+  toMessages
+};
+//# sourceMappingURL=index.js.map

package/dist/spectrum/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/spectrum/index.ts"],
+  "sourcesContent": ["import type { AgentConnection } from '../client.ts';\nimport { AgentAdapter } from './agent-port.ts';\n\nexport { AgentAdapter, CONE } from './agent-port.ts';\nexport { assistant, isBusy, queued, textOf, toMessages } from './messages.ts';\n\nexport function createAgentModel(connection: AgentConnection): { agent: AgentAdapter } {\n  return { agent: new AgentAdapter(connection) };\n}\n"],
+  "mappings": "AACA,SAAS,oBAAoB;AAE7B,SAAS,gBAAAA,eAAc,YAAY;AACnC,SAAS,WAAW,QAAQ,QAAQ,QAAQ,kBAAkB;AAEvD,SAAS,iBAAiB,YAAsD;AACrF,SAAO,EAAE,OAAO,IAAI,aAAa,UAAU,EAAE;AAC/C;",
+  "names": ["AgentAdapter"]
+}

package/dist/spectrum/messages.js

@@ -0,0 +1,161 @@
+function textOf(content) {
+  if (typeof content === "string") return content;
+  return (content ?? []).map((block) => block.type === "text" ? block.text ?? "" : "").join("");
+}
+const paths = (args) => typeof args?.path === "string" ? [args.path] : [];
+function title(name, args) {
+  const subject = args?.command ?? args?.path;
+  return typeof subject === "string" ? `${name} ${subject}` : name;
+}
+function toolCall(block) {
+  return {
+    id: block.id ?? "",
+    name: block.name ?? "tool",
+    title: title(block.name ?? "tool", block.arguments),
+    input: JSON.stringify(block.arguments ?? {}),
+    output: "",
+    status: "running",
+    paths: paths(block.arguments)
+  };
+}
+function part(block) {
+  if (block.type === "text") return { type: "text", text: block.text ?? "" };
+  if (block.type === "thinking") return { type: "thinking", text: block.thinking ?? "" };
+  if (block.type === "toolCall") return { type: "tool", tool: toolCall(block) };
+  return void 0;
+}
+function usage(message) {
+  const used = message.usage;
+  if (!used) return void 0;
+  return {
+    input: used.input ?? 0,
+    output: used.output ?? 0,
+    cost: used.cost?.total ?? 0,
+    cacheRead: used.cacheRead ?? 0,
+    cacheWrite: used.cacheWrite ?? 0
+  };
+}
+const statuses = { error: "error", aborted: "stopped" };
+function assistant(id, message, status) {
+  const blocks = Array.isArray(message.content) ? message.content : [];
+  const parts = blocks.map(part).filter((item) => item !== void 0);
+  if (message.errorMessage)
+    parts.push({ type: "error", message: message.errorMessage, action: "retry" });
+  const used = usage(message);
+  return {
+    id,
+    role: "assistant",
+    parts,
+    status: status ?? statuses[message.stopReason ?? ""] ?? "done",
+    createdAt: message.timestamp ?? 0,
+    ...message.provider && message.model ? { model: `${message.provider}/${message.model}` } : {},
+    ...used ? { usage: used } : {}
+  };
+}
+function user(id, message) {
+  return { id, role: "user", text: textOf(message.content), createdAt: message.timestamp ?? 0 };
+}
+function system(id, entry, text) {
+  const reason = entry.data?.reason;
+  return {
+    id,
+    role: "system",
+    kind: "compaction",
+    text,
+    createdAt: 0,
+    state: "summarized",
+    ...reason ? { trigger: reason } : {}
+  };
+}
+function tools(messages) {
+  const found = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    for (const item of message.parts) if (item.type === "tool") found.set(item.tool.id, item.tool);
+  }
+  return found;
+}
+function settle(calls, result) {
+  const call = calls.get(result.toolCallId ?? "");
+  if (!call) return;
+  call.output = textOf(result.content);
+  call.status = result.isError ? "error" : "done";
+}
+function entryMessage(entry, out, calls) {
+  const id = `e${entry.id}`;
+  const model = entry.model?.[0];
+  if (entry.kind === "pi.user" && model) out.push(user(id, model));
+  else if (entry.kind === "pi.assistant" && model) {
+    const message = assistant(id, model);
+    out.push(message);
+    for (const [key, value] of tools([message])) calls.set(key, value);
+  } else if (entry.kind === "pi.tool-result" && model) settle(calls, model);
+  else if (entry.kind === "pi.compaction") out.push(system(id, entry, textOf(model?.content)));
+}
+const slotStatus = {
+  pending: "running",
+  running: "running",
+  done: "done"
+};
+function live(view, out, calls) {
+  const state = view.docs["pi.live"];
+  for (const slot of state?.tools ?? []) {
+    const call = calls.get(slot.callId);
+    if (call && call.status === "running") {
+      call.status = slotStatus[slot.status] ?? "running";
+      call.output = slot.output ?? call.output;
+    }
+  }
+  const partial = state?.generation?.message;
+  if (partial) out.push(assistant("live", partial, "streaming"));
+  for (const compaction of state?.compactions ?? []) {
+    out.push({
+      id: `compaction-${compaction.taskId}`,
+      role: "system",
+      kind: "compaction",
+      text: "",
+      createdAt: 0,
+      state: "summarizing",
+      trigger: compaction.reason
+    });
+  }
+  const retry = state?.generation?.retry;
+  if (retry)
+    out.push({
+      id: "retry",
+      role: "system",
+      kind: "notice",
+      text: retry.error,
+      createdAt: retry.at
+    });
+}
+function toMessages(view) {
+  const out = [];
+  if (!view) return out;
+  const calls = /* @__PURE__ */ new Map();
+  for (const entry of view.entries) entryMessage(entry, out, calls);
+  live(view, out, calls);
+  return out;
+}
+function isBusy(view) {
+  return Boolean(view?.docs["pi.live"]?.run);
+}
+function queued(view) {
+  const items = view?.docs["pi.inbox"]?.items ?? [];
+  return items.filter((item) => item.mode !== "write").map((item) => ({
+    id: `q${item.id}`,
+    role: "user",
+    text: textOf(item.content),
+    createdAt: 0,
+    queued: true,
+    mode: item.mode === "steer" ? "steer" : "queue"
+  }));
+}
+export {
+  assistant,
+  isBusy,
+  queued,
+  textOf,
+  toMessages
+};
+//# sourceMappingURL=messages.js.map

package/dist/spectrum/messages.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/spectrum/messages.ts"],
+  "sourcesContent": ["import type {\n  AssistantMessage,\n  AssistantStatus,\n  Message,\n  MessagePart,\n  SystemMessage,\n  ToolCall,\n  ToolStatus,\n  Usage,\n  UserMessage,\n} from '@ai-ecoverse/slicc-spectrum/ui';\nimport type { ConversationView, EntryRecord } from '@earendil-works/pi-durable';\n\ntype Json = Record<string, unknown>;\n\ninterface Block {\n  type: string;\n  text?: string;\n  thinking?: string;\n  id?: string;\n  name?: string;\n  arguments?: Json;\n}\n\ninterface ModelMessage {\n  role: string;\n  content?: string | Block[];\n  timestamp?: number;\n  stopReason?: string;\n  errorMessage?: string;\n  provider?: string;\n  model?: string;\n  usage?: {\n    input?: number;\n    output?: number;\n    cacheRead?: number;\n    cacheWrite?: number;\n    cost?: { total?: number };\n  };\n  toolCallId?: string;\n  isError?: boolean;\n}\n\ninterface Slot {\n  callId: string;\n  status: string;\n  output?: string;\n}\n\ninterface Live {\n  run?: unknown;\n  generation?: { message?: ModelMessage; retry?: { at: number; error: string } };\n  tools?: Slot[];\n  compactions?: { taskId: number; reason: string }[];\n}\n\nexport function textOf(content: ModelMessage['content']): string {\n  if (typeof content === 'string') return content;\n  return (content ?? []).map((block) => (block.type === 'text' ? (block.text ?? '') : '')).join('');\n}\n\nconst paths = (args: Json | undefined): string[] =>\n  typeof args?.path === 'string' ? [args.path] : [];\n\nfunction title(name: string, args: Json | undefined): string {\n  const subject = args?.command ?? args?.path;\n  return typeof subject === 'string' ? `${name} ${subject}` : name;\n}\n\nfunction toolCall(block: Block): ToolCall {\n  return {\n    id: block.id ?? '',\n    name: block.name ?? 'tool',\n    title: title(block.name ?? 'tool', block.arguments),\n    input: JSON.stringify(block.arguments ?? {}),\n    output: '',\n    status: 'running',\n    paths: paths(block.arguments),\n  };\n}\n\nfunction part(block: Block): MessagePart | undefined {\n  if (block.type === 'text') return { type: 'text', text: block.text ?? '' };\n  if (block.type === 'thinking') return { type: 'thinking', text: block.thinking ?? '' };\n  if (block.type === 'toolCall') return { type: 'tool', tool: toolCall(block) };\n  return undefined;\n}\n\nfunction usage(message: ModelMessage): Usage | undefined {\n  const used = message.usage;\n  if (!used) return undefined;\n  return {\n    input: used.input ?? 0,\n    output: used.output ?? 0,\n    cost: used.cost?.total ?? 0,\n    cacheRead: used.cacheRead ?? 0,\n    cacheWrite: used.cacheWrite ?? 0,\n  };\n}\n\nconst statuses: Record<string, AssistantStatus> = { error: 'error', aborted: 'stopped' };\n\nexport function assistant(\n  id: string,\n  message: ModelMessage,\n  status?: AssistantStatus\n): AssistantMessage {\n  const blocks = Array.isArray(message.content) ? message.content : [];\n  const parts = blocks.map(part).filter((item): item is MessagePart => item !== undefined);\n  if (message.errorMessage)\n    parts.push({ type: 'error', message: message.errorMessage, action: 'retry' });\n  const used = usage(message);\n  return {\n    id,\n    role: 'assistant',\n    parts,\n    status: status ?? statuses[message.stopReason ?? ''] ?? 'done',\n    createdAt: message.timestamp ?? 0,\n    ...(message.provider && message.model ? { model: `${message.provider}/${message.model}` } : {}),\n    ...(used ? { usage: used } : {}),\n  };\n}\n\nfunction user(id: string, message: ModelMessage): UserMessage {\n  return { id, role: 'user', text: textOf(message.content), createdAt: message.timestamp ?? 0 };\n}\n\nfunction system(id: string, entry: EntryRecord, text: string): SystemMessage {\n  const reason = (entry.data as Json | undefined)?.reason as SystemMessage['trigger'] | undefined;\n  return {\n    id,\n    role: 'system',\n    kind: 'compaction',\n    text,\n    createdAt: 0,\n    state: 'summarized',\n    ...(reason ? { trigger: reason } : {}),\n  };\n}\n\nfunction tools(messages: Message[]): Map<string, ToolCall> {\n  const found = new Map<string, ToolCall>();\n  for (const message of messages) {\n    if (message.role !== 'assistant') continue;\n    for (const item of message.parts) if (item.type === 'tool') found.set(item.tool.id, item.tool);\n  }\n  return found;\n}\n\nfunction settle(calls: Map<string, ToolCall>, result: ModelMessage): void {\n  const call = calls.get(result.toolCallId ?? '');\n  if (!call) return;\n  call.output = textOf(result.content);\n  call.status = result.isError ? 'error' : 'done';\n}\n\nfunction entryMessage(entry: EntryRecord, out: Message[], calls: Map<string, ToolCall>): void {\n  const id = `e${entry.id}`;\n  const model = entry.model?.[0] as ModelMessage | undefined;\n  if (entry.kind === 'pi.user' && model) out.push(user(id, model));\n  else if (entry.kind === 'pi.assistant' && model) {\n    const message = assistant(id, model);\n    out.push(message);\n    for (const [key, value] of tools([message])) calls.set(key, value);\n  } else if (entry.kind === 'pi.tool-result' && model) settle(calls, model);\n  else if (entry.kind === 'pi.compaction') out.push(system(id, entry, textOf(model?.content)));\n}\n\nconst slotStatus: Record<string, ToolStatus> = {\n  pending: 'running',\n  running: 'running',\n  done: 'done',\n};\n\nfunction live(view: ConversationView, out: Message[], calls: Map<string, ToolCall>): void {\n  const state = view.docs['pi.live'] as Live | undefined;\n  for (const slot of state?.tools ?? []) {\n    const call = calls.get(slot.callId);\n    if (call && call.status === 'running') {\n      call.status = slotStatus[slot.status] ?? 'running';\n      call.output = slot.output ?? call.output;\n    }\n  }\n  const partial = state?.generation?.message;\n  if (partial) out.push(assistant('live', partial, 'streaming'));\n  for (const compaction of state?.compactions ?? []) {\n    out.push({\n      id: `compaction-${compaction.taskId}`,\n      role: 'system',\n      kind: 'compaction',\n      text: '',\n      createdAt: 0,\n      state: 'summarizing',\n      trigger: compaction.reason as SystemMessage['trigger'],\n    });\n  }\n  const retry = state?.generation?.retry;\n  if (retry)\n    out.push({\n      id: 'retry',\n      role: 'system',\n      kind: 'notice',\n      text: retry.error,\n      createdAt: retry.at,\n    });\n}\n\nexport function toMessages(view: ConversationView | undefined): Message[] {\n  const out: Message[] = [];\n  if (!view) return out;\n  const calls = new Map<string, ToolCall>();\n  for (const entry of view.entries) entryMessage(entry, out, calls);\n  live(view, out, calls);\n  return out;\n}\n\nexport function isBusy(view: ConversationView | undefined): boolean {\n  return Boolean((view?.docs['pi.live'] as Live | undefined)?.run);\n}\n\nexport function queued(view: ConversationView | undefined): UserMessage[] {\n  const items = ((view?.docs['pi.inbox'] as { items?: Json[] } | undefined)?.items ?? []) as {\n    id: number;\n    mode: string;\n    content?: ModelMessage['content'];\n  }[];\n  return items\n    .filter((item) => item.mode !== 'write')\n    .map((item) => ({\n      id: `q${item.id}`,\n      role: 'user',\n      text: textOf(item.content),\n      createdAt: 0,\n      queued: true,\n      mode: item.mode === 'steer' ? 'steer' : 'queue',\n    }));\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/client.d.ts

@@ -0,0 +1,14 @@
+import { type Context, type ReplicatedState } from '@earendil-works/chord';
+import type { ConversationView } from '@earendil-works/pi-durable';
+import { AgentControl, type SendMode } from './services.ts';
+import { type PortEndpoint } from './wire.ts';
+export interface AgentConnection {
+    readonly serverId: string;
+    readonly control: AgentControl;
+    readonly transcript: ReplicatedState<ConversationView>;
+    prompt(text: string, whenBusy?: SendMode): Promise<string>;
+    close(): Promise<void>;
+}
+export declare function connectAgent(endpoint: PortEndpoint, options?: {
+    context?: Context;
+}): Promise<AgentConnection>;

package/dist/types/control.d.ts

@@ -0,0 +1,4 @@
+import { type Conversation, type Harness, type SubmissionId } from '@earendil-works/pi-durable';
+import type { AgentControl } from './services.ts';
+export declare function submissionId(value: string): SubmissionId | undefined;
+export declare function createAgentControl(harness: Harness, conversation: Conversation): AgentControl;

package/dist/types/host.d.ts

@@ -0,0 +1,13 @@
+import { type Context } from '@earendil-works/chord';
+import type { Agent } from './agent.ts';
+import { type PortEndpoint } from './wire.ts';
+export interface AgentHost {
+    readonly serverId: string;
+    readonly agent: Agent;
+    connect(endpoint: PortEndpoint): void;
+    close(): Promise<void>;
+}
+export declare function hostAgent(agent: Agent, options?: {
+    serverId?: string;
+    context?: Context;
+}): Promise<AgentHost>;

package/dist/types/index.d.ts

@@ -1,3 +1,9 @@
 export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';
-export { type AgentClient, type AgentReply, type AgentRequest, connectAgent, type MessageEndpoint, serveAgent, } from './port.ts';
+export { type AgentConnection, connectAgent } from './client.ts';
+export { createAgentControl } from './control.ts';
+export { type AgentHost, hostAgent } from './host.ts';
+export { AGENT_LOCK, type AgentOwner, type AgentWorker, type OwnerOptions, startAgent, } from './owner.ts';
+export { AGENT_SESSION, AgentControl, AgentSessions, type AgentSettingsChange, AgentTranscript, type OperationError, type PromptResult, type SendMode, type SendRequest, type SendResponse, } from './services.ts';
 export { AGENT_DIRECTORY, type OpfsSqliteOptions, openMemorySqliteStorage, openOpfsSqliteStorage, WasmSqliteDatabase, } from './sqlite.ts';
+export { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';
+export { serveConnections, type WorkerScope } from './worker.ts';

package/dist/types/owner.d.ts

@@ -0,0 +1,21 @@
+import { type AgentConnection } from './client.ts';
+import type { PortEndpoint } from './wire.ts';
+export declare const AGENT_LOCK = "slicc-agent";
+export interface AgentWorker {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+    terminate(): void;
+}
+export interface AgentOwner {
+    connect(): Promise<AgentConnection>;
+    restart(): void;
+    release(): void;
+}
+export interface OwnerOptions {
+    worker: () => AgentWorker;
+    locks?: LockManager;
+    channel?: () => {
+        port1: PortEndpoint;
+        port2: Transferable;
+    };
+}
+export declare function startAgent(options: OwnerOptions): Promise<AgentOwner>;

package/dist/types/services.d.ts

@@ -0,0 +1,59 @@
+import { type Context, type ReplicatedState } from '@earendil-works/chord';
+import type { ConversationView } from '@earendil-works/pi-durable';
+export type SendMode = 'steer' | 'followUp' | 'reject';
+export interface SendRequest {
+    text: string;
+    whenBusy: SendMode;
+    requestId: string | null;
+}
+export interface OperationError {
+    code: string;
+    message: string;
+}
+export type SendResponse = {
+    accepted: true;
+    submissionId: string;
+    error: null;
+} | {
+    accepted: false;
+    submissionId: null;
+    error: OperationError;
+};
+export type PromptResult = {
+    status: 'done';
+    text: string;
+    reason: null;
+} | {
+    status: 'unanswered';
+    text: null;
+    reason: string;
+};
+export interface AgentControl {
+    send(request: SendRequest, context: Context): Promise<SendResponse>;
+    wait(submissionId: string, context: Context): Promise<PromptResult>;
+    withdraw(submissionId: string, context: Context): Promise<{
+        outcome: 'withdrawn' | 'already_placed' | 'not_found';
+    }>;
+    abort(context: Context): Promise<void>;
+    compact(instructions: string | null, context: Context): Promise<SendResponse>;
+    reset(handoff: string | null, context: Context): Promise<void>;
+    configure(change: AgentSettingsChange, context: Context): Promise<void>;
+}
+export interface AgentSettingsChange {
+    model: {
+        provider: string;
+        modelId: string;
+    } | null;
+    thinkingLevel: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;
+}
+export declare const AgentControl: import("@earendil-works/chord").Service<AgentControl>;
+export interface AgentTranscript {
+    readonly state: ReplicatedState<ConversationView>;
+}
+export declare const AgentTranscript: import("@earendil-works/chord").Service<AgentTranscript>;
+export interface AgentSessions {
+    attach(sessionId: string, context: Context): Promise<void>;
+    detach(context: Context): Promise<void>;
+}
+export declare const AgentSessions: import("@earendil-works/chord").Service<AgentSessions>;
+export declare const AGENT_SESSION = "agent";

package/dist/types/spectrum/agent-port.d.ts

@@ -0,0 +1,32 @@
+import type { Agent, AgentEvents, AgentPort, FrozenCone, Message, Outgoing, SlashCommand, Thinking, UserMessage } from '@ai-ecoverse/slicc-spectrum/ui';
+import type { AgentConnection } from '../client.ts';
+import { Emitter } from './emitter.ts';
+export declare const CONE = "cone";
+export declare class AgentAdapter extends Emitter<AgentEvents> implements AgentPort {
+    #private;
+    constructor(connection: AgentConnection);
+    ready(): Promise<void>;
+    list(): readonly Agent[];
+    active(): string;
+    select(): void;
+    messages(): readonly Message[];
+    send(_agentId: string, input: string | Outgoing): Promise<void>;
+    stop(): void;
+    busy(): boolean;
+    queue(): readonly UserMessage[];
+    unqueue(_agentId: string, messageId: string): void;
+    suggestion(): string | null;
+    answer(): void;
+    resolveLick(): void;
+    compact(): void;
+    clear(): void;
+    setModel(_agentId: string, model: string): void;
+    setThinking(_agentId: string, level: Thinking): void;
+    older(): Promise<readonly Message[]>;
+    commands(): readonly SlashCommand[];
+    createScoop(): Agent;
+    frozen(): readonly FrozenCone[];
+    freeze(): void;
+    thaw(): Agent | null;
+    discard(): void;
+}

package/dist/types/spectrum/emitter.d.ts

@@ -0,0 +1,7 @@
+type Listener<T> = (detail: T) => void;
+export declare class Emitter<Events extends object> {
+    #private;
+    on<K extends keyof Events>(type: K, listener: Listener<Events[K]>): () => void;
+    emit<K extends keyof Events>(type: K, detail: Events[K]): void;
+}
+export {};

package/dist/types/spectrum/index.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConnection } from '../client.ts';
+import { AgentAdapter } from './agent-port.ts';
+export { AgentAdapter, CONE } from './agent-port.ts';
+export { assistant, isBusy, queued, textOf, toMessages } from './messages.ts';
+export declare function createAgentModel(connection: AgentConnection): {
+    agent: AgentAdapter;
+};

package/dist/types/spectrum/messages.d.ts

@@ -0,0 +1,37 @@
+import type { AssistantMessage, AssistantStatus, Message, UserMessage } from '@ai-ecoverse/slicc-spectrum/ui';
+import type { ConversationView } from '@earendil-works/pi-durable';
+type Json = Record<string, unknown>;
+interface Block {
+    type: string;
+    text?: string;
+    thinking?: string;
+    id?: string;
+    name?: string;
+    arguments?: Json;
+}
+interface ModelMessage {
+    role: string;
+    content?: string | Block[];
+    timestamp?: number;
+    stopReason?: string;
+    errorMessage?: string;
+    provider?: string;
+    model?: string;
+    usage?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        cost?: {
+            total?: number;
+        };
+    };
+    toolCallId?: string;
+    isError?: boolean;
+}
+export declare function textOf(content: ModelMessage['content']): string;
+export declare function assistant(id: string, message: ModelMessage, status?: AssistantStatus): AssistantMessage;
+export declare function toMessages(view: ConversationView | undefined): Message[];
+export declare function isBusy(view: ConversationView | undefined): boolean;
+export declare function queued(view: ConversationView | undefined): UserMessage[];
+export {};

package/dist/types/wire.d.ts

@@ -0,0 +1,27 @@
+import type { ByteTransportFactory } from '@earendil-works/pi-client';
+import type { ServerListener } from '@earendil-works/pi-server';
+type ByteConnectionAcceptor = Parameters<ServerListener['start']>[0];
+export interface PortEndpoint {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    addEventListener(type: 'close' | 'messageerror' | 'error', listener: (event: Event) => void): void;
+    start?(): void;
+    close?(): void;
+}
+export declare function withUnrefTimers<T>(run: () => T, scope?: {
+    setTimeout: typeof setTimeout;
+}): T;
+export declare class PortListener implements ServerListener {
+    #private;
+    constructor(serverId: string);
+    start(accept: ByteConnectionAcceptor): Promise<void>;
+    close(): Promise<void>;
+    connect(endpoint: PortEndpoint): void;
+}
+export declare class PortChannel {
+    #private;
+    readonly hello: Promise<string>;
+    constructor(endpoint: PortEndpoint);
+    readonly transport: ByteTransportFactory;
+}
+export {};

package/dist/types/worker.d.ts

@@ -0,0 +1,5 @@
+import type { AgentHost } from './host.ts';
+export interface WorkerScope {
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+}
+export declare function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void;

package/dist/wire.js

@@ -0,0 +1,164 @@
+function post(endpoint, chunk) {
+  const copy = chunk.slice();
+  endpoint.postMessage(copy, [copy.buffer]);
+}
+function unrefable(id) {
+  return {
+    unref() {
+      return this;
+    },
+    ref() {
+      return this;
+    },
+    [Symbol.toPrimitive]: () => id
+  };
+}
+function withUnrefTimers(run, scope = globalThis) {
+  const original = scope.setTimeout;
+  scope.setTimeout = ((...args) => {
+    const id = original(...args);
+    return typeof id === "number" ? unrefable(id) : id;
+  });
+  try {
+    return run();
+  } finally {
+    scope.setTimeout = original;
+  }
+}
+class PortConnection {
+  closed = false;
+  #endpoint;
+  #ended;
+  constructor(endpoint, ended) {
+    this.#endpoint = endpoint;
+    this.#ended = ended;
+  }
+  async send(chunk) {
+    if (this.closed) throw new Error("connection is closed");
+    post(this.#endpoint, chunk);
+  }
+  close(finalChunk) {
+    if (this.closed) return;
+    if (finalChunk) post(this.#endpoint, finalChunk);
+    this.closed = true;
+    this.#endpoint.postMessage({ close: true });
+    this.#endpoint.close?.();
+    this.#ended();
+  }
+  end() {
+    this.closed = true;
+    this.#ended();
+  }
+}
+class PortListener {
+  #serverId;
+  #connections = /* @__PURE__ */ new Set();
+  #accept;
+  constructor(serverId) {
+    this.#serverId = serverId;
+  }
+  async start(accept) {
+    this.#accept = accept;
+  }
+  async close() {
+    for (const connection of [...this.#connections]) connection.close();
+    this.#accept = void 0;
+  }
+  connect(endpoint) {
+    const accept = this.#accept;
+    if (!accept) throw new Error("agent host is not listening");
+    const connection = new PortConnection(endpoint, () => this.#connections.delete(connection));
+    this.#connections.add(connection);
+    const handler = withUnrefTimers(() => accept(connection));
+    endpoint.addEventListener("message", ({ data }) => {
+      if (data instanceof Uint8Array) handler.onData(data);
+      else if (data?.close) {
+        connection.end();
+        handler.onClose();
+      }
+    });
+    const failed = (event) => {
+      connection.end();
+      handler.onError(new Error(`agent port ${event.type}`));
+    };
+    endpoint.addEventListener("messageerror", failed);
+    endpoint.addEventListener("close", () => {
+      if (connection.closed) return;
+      connection.end();
+      handler.onClose();
+    });
+    endpoint.start?.();
+    endpoint.postMessage({ hello: this.#serverId });
+  }
+}
+class PortChannel {
+  hello;
+  #endpoint;
+  #queue = [];
+  #handlers;
+  #ended;
+  #greet;
+  #refuse;
+  constructor(endpoint) {
+    this.#endpoint = endpoint;
+    this.hello = new Promise((greet, refuse) => {
+      this.#greet = greet;
+      this.#refuse = refuse;
+    });
+    endpoint.addEventListener("message", ({ data }) => this.#receive(data));
+    endpoint.addEventListener(
+      "messageerror",
+      (event) => this.#end(new Error(`agent port ${event.type}`))
+    );
+    endpoint.addEventListener("error", (event) => this.#end(new Error(`agent port ${event.type}`)));
+    endpoint.addEventListener("close", () => this.#end("close"));
+    endpoint.start?.();
+  }
+  transport = (handlers) => {
+    this.#handlers = handlers;
+    for (const chunk of this.#queue.splice(0)) handlers.onData(chunk);
+    if (this.#ended) this.#deliver(this.#ended);
+    return {
+      send: async (chunk) => {
+        if (this.#ended) throw new Error("agent port is closed");
+        post(this.#endpoint, chunk);
+      },
+      close: () => {
+        if (this.#ended) return;
+        this.#ended = "close";
+        this.#refuse(new Error("agent port closed before hello"));
+        this.#endpoint.postMessage({ close: true });
+        this.#endpoint.close?.();
+      }
+    };
+  };
+  #receive(frame) {
+    if (frame instanceof Uint8Array) {
+      if (this.#handlers) this.#handlers.onData(frame);
+      else this.#queue.push(frame);
+    } else if ("hello" in frame) {
+      this.#greet(frame.hello);
+    } else {
+      this.#end("close");
+    }
+  }
+  #end(reason) {
+    if (this.#ended) return;
+    this.#ended = reason;
+    this.#refuse(reason === "close" ? new Error("agent port closed before hello") : reason);
+    this.#deliver(reason);
+  }
+  #deliver(reason) {
+    const handlers = this.#handlers;
+    if (!handlers) return;
+    this.#handlers = void 0;
+    if (reason === "close") handlers.onClose();
+    else handlers.onError(reason);
+  }
+}
+export {
+  PortChannel,
+  PortListener,
+  withUnrefTimers
+};
+//# sourceMappingURL=wire.js.map