@agentorg/cli 0.0.6 → 0.0.8

package/dist/node_modules/@agentorg/interfaces/dist/src/chat.d.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+/** The longest title a chat has. */
+export declare const CHAT_TITLE_MAX = 200;
 /**
  * A tool call a `tool` message stands for: its name, whether it is `running` or ended `done` or
  * `refused`, and its input (the call's JSON arguments) and output (its JSON result, or the
@@ -39,44 +41,60 @@ export declare const ChatMessage: z.ZodObject<{
         output: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const ChatState: z.ZodEnum<{
-    error: "error";
-    idle: "idle";
-    thinking: "thinking";
-    tool: "tool";
-}>;
-/**
- * What the agent is doing. On `error`, `detail.code` is the refusal's code, such as the model's
- * `usage_limit` or `not_signed_in`, so a view can offer the right action.
- */
+/** What the agent is doing: `working` while it answers anything, in any chat. */
 export declare const ChatStatus: z.ZodObject<{
     state: z.ZodEnum<{
-        error: "error";
         idle: "idle";
-        thinking: "thinking";
-        tool: "tool";
+        working: "working";
     }>;
-    detail: z.ZodOptional<z.ZodObject<{
+}, z.core.$strip>;
+/**
+ * One of an agent's chats, as a list shows it. Its `title` is its first message's first line until
+ * it is renamed. `latest` is its newest reply, so a view can tell what is new without reading the
+ * chat. `problem` is there while a message in it got no answer, until its next reply.
+ */
+export declare const ChatEntry: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    at: z.ZodString;
+    latest: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    problem: z.ZodOptional<z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
     }, z.core.$strip>>;
+    archived: z.ZodBoolean;
 }, z.core.$strip>;
 /**
- * `chat@1`: a conversation with an agent. `send` starts a turn, whose messages, streaming text and
- * status arrive as events. Events are live only: `history` is the record, and `state` the status
- * now.
+ * `chat@1`: an agent's chats. A chat is the messages sent in it and nothing more: `send` with no
+ * `chat` starts one, and with one, goes on in it. Messages and streaming text arrive as events,
+ * each naming its chat. What works is the agent, not a chat: `status` says when it starts and
+ * when it is done. Events are live only: `history` is a chat's record, `state` the agent's status
+ * now, and `list` the chats. A provider that can't take
+ * a message now refuses it `busy`. A call naming a chat the agent doesn't have is refused
+ * `unknown`.
  */
 export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
+    /**
+     * Send this message in `chat`, or in a new chat; the result says which. The agent answers it
+     * in that chat. An archived chat takes a message like any other, and stays archived. Refused
+     * `busy` when the provider can't take it now.
+     */
     send: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodOptional<z.ZodString>;
         text: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
+        chat: z.ZodString;
         messageId: z.ZodString;
     }, z.core.$strip>>;
     /**
-     * Messages before `before` (or the newest), oldest first; `more` when older ones remain. A
-     * provider returns fewer than `limit` when a page would not fit one frame.
+     * A chat's messages before `before` (or the newest), oldest first; `more` when older ones
+     * remain. A provider returns fewer than `limit` when a page would not fit one frame.
      */
     history: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodString;
         before: z.ZodOptional<z.ZodString>;
         limit: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
@@ -102,43 +120,50 @@ export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
         }, z.core.$strip>>;
         more: z.ZodBoolean;
     }, z.core.$strip>>;
-    /** Stop the current turn, if any. */
-    cancel: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /** The status now, as the latest `status` event said; for a view opened mid-turn. */
+    /** The agent's status now, as its latest `status` event said; for a view opened late. */
     state: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
         state: z.ZodEnum<{
-            error: "error";
             idle: "idle";
-            thinking: "thinking";
-            tool: "tool";
+            working: "working";
         }>;
-        detail: z.ZodOptional<z.ZodObject<{
-            code: z.ZodString;
-            message: z.ZodString;
-        }, z.core.$strip>>;
     }, z.core.$strip>>;
     /**
-     * Run the last turn again from the record, without recording the person's message again;
-     * `messageId` is that message's. Refused `busy` during a turn, and `nothing_to_retry` when no
-     * message has been sent.
+     * The chats after `before` in the list (or from its start), newest first by their last
+     * message; `more` when others follow. Those not archived, or with `archived`, those that are.
+     * A message sent in a chat moves it to the front, so a later page may repeat a chat that
+     * moved, and never leaves out one that didn't: the `chat` event says each that did. A `before`
+     * the agent doesn't have gives an empty page.
      */
-    retry: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        messageId: z.ZodString;
-    }, z.core.$strip>>;
-    /** The models this agent can use, and the one chosen; none chosen means the provider's default. */
-    models: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        models: z.ZodArray<z.ZodObject<{
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        archived: z.ZodOptional<z.ZodBoolean>;
+        before: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        chats: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
-            name: z.ZodString;
+            title: z.ZodString;
+            at: z.ZodString;
+            latest: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                at: z.ZodString;
+            }, z.core.$strip>>;
+            problem: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            archived: z.ZodBoolean;
         }, z.core.$strip>>;
-        current: z.ZodOptional<z.ZodString>;
+        more: z.ZodBoolean;
     }, z.core.$strip>>;
-    /**
-     * Choose the model for this agent's next requests, kept with the agent; with no `model`, go
-     * back to the provider's default. Refused `unknown` when the model isn't one of `models`.
-     */
-    setModel: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
+    /** Give a chat another title: one line, so only the first line of `title` is kept. */
+    rename: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** Put a chat among the archived ones, or back. It stays readable either way. */
+    archive: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodString;
+        archived: z.ZodBoolean;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
 }, {
     message: import("@agentorg/sdk").EventSpec<z.ZodObject<{
@@ -160,22 +185,37 @@ export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
             input: z.ZodOptional<z.ZodString>;
             output: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        chat: z.ZodString;
     }, z.core.$strip>>;
     /** Text of the assistant message `id`, as it streams; its `message` event follows. */
     delta: import("@agentorg/sdk").EventSpec<z.ZodObject<{
+        chat: z.ZodString;
         id: z.ZodString;
         text: z.ZodString;
     }, z.core.$strip>>;
+    /** The agent's status, when it changes. */
     status: import("@agentorg/sdk").EventSpec<z.ZodObject<{
         state: z.ZodEnum<{
-            error: "error";
             idle: "idle";
-            thinking: "thinking";
-            tool: "tool";
+            working: "working";
         }>;
-        detail: z.ZodOptional<z.ZodObject<{
+    }, z.core.$strip>>;
+    /**
+     * A chat as it now is: it was started, renamed or archived, a message was sent in it, or one
+     * got no answer.
+     */
+    chat: import("@agentorg/sdk").EventSpec<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        at: z.ZodString;
+        latest: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>>;
+        problem: z.ZodOptional<z.ZodObject<{
             code: z.ZodString;
             message: z.ZodString;
         }, z.core.$strip>>;
+        archived: z.ZodBoolean;
     }, z.core.$strip>>;
 }, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/chat.js

@@ -1,7 +1,11 @@
 import { defineInterface, event, method } from "@agentorg/sdk";
 import { z } from "zod";
 const MessageId = z.string().min(1).max(128);
-const ChatModelId = z.string().min(1).max(128);
+const ChatId = z.string().min(1).max(128);
+/** The longest title a chat has. */
+export const CHAT_TITLE_MAX = 200;
+/** One chat of an agent's, where a call names it. */
+const OnChat = z.object({ chat: ChatId });
 /**
  * A tool call a `tool` message stands for: its name, whether it is `running` or ended `done` or
  * `refused`, and its input (the call's JSON arguments) and output (its JSON result, or the
@@ -26,68 +30,99 @@ export const ChatMessage = z.object({
     at: z.string().max(64),
     tool: ChatTool.optional(),
 });
-export const ChatState = z.enum(["idle", "thinking", "tool", "error"]);
+/** What the agent is doing: `working` while it answers anything, in any chat. */
+export const ChatStatus = z.object({ state: z.enum(["idle", "working"]) });
 /**
- * What the agent is doing. On `error`, `detail.code` is the refusal's code, such as the model's
+ * Why a message in a chat got no answer. `code` is the refusal's code, such as the model's
  * `usage_limit` or `not_signed_in`, so a view can offer the right action.
  */
-export const ChatStatus = z.object({
-    state: ChatState,
-    detail: z.object({ code: z.string(), message: z.string() }).optional(),
+const ChatProblem = z.object({ code: z.string().max(128), message: z.string().max(2000) });
+/**
+ * One of an agent's chats, as a list shows it. Its `title` is its first message's first line until
+ * it is renamed. `latest` is its newest reply, so a view can tell what is new without reading the
+ * chat. `problem` is there while a message in it got no answer, until its next reply.
+ */
+export const ChatEntry = z.object({
+    id: ChatId,
+    title: z.string().max(CHAT_TITLE_MAX),
+    /** When it started: an ISO 8601 time. */
+    at: z.string().max(64),
+    latest: z.object({ id: MessageId, at: z.string().max(64) }).optional(),
+    problem: ChatProblem.optional(),
+    archived: z.boolean(),
 });
 /**
- * `chat@1`: a conversation with an agent. `send` starts a turn, whose messages, streaming text and
- * status arrive as events. Events are live only: `history` is the record, and `state` the status
- * now.
+ * `chat@1`: an agent's chats. A chat is the messages sent in it and nothing more: `send` with no
+ * `chat` starts one, and with one, goes on in it. Messages and streaming text arrive as events,
+ * each naming its chat. What works is the agent, not a chat: `status` says when it starts and
+ * when it is done. Events are live only: `history` is a chat's record, `state` the agent's status
+ * now, and `list` the chats. A provider that can't take
+ * a message now refuses it `busy`. A call naming a chat the agent doesn't have is refused
+ * `unknown`.
  */
 export const chat = defineInterface({
     name: "chat",
     major: 1,
     kind: "rpc",
     methods: {
+        /**
+         * Send this message in `chat`, or in a new chat; the result says which. The agent answers it
+         * in that chat. An archived chat takes a message like any other, and stays archived. Refused
+         * `busy` when the provider can't take it now.
+         */
         send: method({
-            input: z.object({ text: z.string().min(1).max(100_000).regex(/\S/) }),
-            output: z.object({ messageId: MessageId }),
+            input: z.object({
+                chat: ChatId.optional(),
+                text: z.string().min(1).max(100_000).regex(/\S/),
+            }),
+            output: z.object({ chat: ChatId, messageId: MessageId }),
         }),
         /**
-         * Messages before `before` (or the newest), oldest first; `more` when older ones remain. A
-         * provider returns fewer than `limit` when a page would not fit one frame.
+         * A chat's messages before `before` (or the newest), oldest first; `more` when older ones
+         * remain. A provider returns fewer than `limit` when a page would not fit one frame.
          */
         history: method({
-            input: z.object({
+            input: OnChat.extend({
                 before: MessageId.optional(),
                 limit: z.number().int().min(1).max(200).optional(),
             }),
             output: z.object({ messages: z.array(ChatMessage), more: z.boolean() }),
         }),
-        /** Stop the current turn, if any. */
-        cancel: method({ input: z.object({}), output: z.object({}) }),
-        /** The status now, as the latest `status` event said; for a view opened mid-turn. */
+        /** The agent's status now, as its latest `status` event said; for a view opened late. */
         state: method({ input: z.object({}), output: ChatStatus }),
         /**
-         * Run the last turn again from the record, without recording the person's message again;
-         * `messageId` is that message's. Refused `busy` during a turn, and `nothing_to_retry` when no
-         * message has been sent.
+         * The chats after `before` in the list (or from its start), newest first by their last
+         * message; `more` when others follow. Those not archived, or with `archived`, those that are.
+         * A message sent in a chat moves it to the front, so a later page may repeat a chat that
+         * moved, and never leaves out one that didn't: the `chat` event says each that did. A `before`
+         * the agent doesn't have gives an empty page.
          */
-        retry: method({ input: z.object({}), output: z.object({ messageId: MessageId }) }),
-        /** The models this agent can use, and the one chosen; none chosen means the provider's default. */
-        models: method({
-            input: z.object({}),
-            output: z.object({
-                models: z.array(z.object({ id: ChatModelId, name: z.string().max(256) })),
-                current: ChatModelId.optional(),
+        list: method({
+            input: z.object({
+                archived: z.boolean().optional(),
+                before: ChatId.optional(),
+                limit: z.number().int().min(1).max(200).optional(),
             }),
+            output: z.object({ chats: z.array(ChatEntry), more: z.boolean() }),
         }),
-        /**
-         * Choose the model for this agent's next requests, kept with the agent; with no `model`, go
-         * back to the provider's default. Refused `unknown` when the model isn't one of `models`.
-         */
-        setModel: method({ input: z.object({ model: ChatModelId.optional() }), output: z.object({}) }),
+        /** Give a chat another title: one line, so only the first line of `title` is kept. */
+        rename: method({
+            input: OnChat.extend({ title: z.string().min(1).max(CHAT_TITLE_MAX).regex(/\S/) }),
+            output: z.object({}),
+        }),
+        /** Put a chat among the archived ones, or back. It stays readable either way. */
+        archive: method({ input: OnChat.extend({ archived: z.boolean() }), output: z.object({}) }),
     },
     events: {
-        message: event(ChatMessage),
+        message: event(ChatMessage.extend({ chat: ChatId })),
         /** Text of the assistant message `id`, as it streams; its `message` event follows. */
-        delta: event(z.object({ id: MessageId, text: z.string() })),
+        delta: event(z.object({ chat: ChatId, id: MessageId, text: z.string() })),
+        /** The agent's status, when it changes. */
         status: event(ChatStatus),
+        /**
+         * A chat as it now is: it was started, renamed or archived, a message was sent in it, or one
+         * got no answer.
+         */
+        chat: event(ChatEntry),
     },
 });

package/dist/node_modules/@agentorg/interfaces/dist/src/connection.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/** A way a provider makes connections, such as `url` or `command`. */
+export declare const ConnectionKind: z.ZodString;
+/** `connecting` before its first success, `connected`, or `down` and being tried again. */
+export declare const ConnectionState: z.ZodEnum<{
+    connected: "connected";
+    connecting: "connecting";
+    down: "down";
+}>;
+/** A connection's tools, for people to read; a provider cuts a long description to fit. */
+export declare const ConnectionTool: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** How a connection stands now: `detail` says why it is down, and never holds a secret. */
+export declare const ConnectionStatus: z.ZodObject<{
+    state: z.ZodEnum<{
+        connected: "connected";
+        connecting: "connecting";
+        down: "down";
+    }>;
+    detail: z.ZodOptional<z.ZodString>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The parameters of a connection, fitting its kind's `params` schema. */
+export declare const ConnectionParams: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+/**
+ * What a server needs and shouldn't be seen, by name, such as a bearer token. Write-only: the values
+ * cross once, in `create`, and go only to the provider's own private file.
+ */
+export declare const ConnectionSecrets: z.ZodRecord<z.ZodString, z.ZodString>;
+/** What a connection attaches to or runs, for people to read: never a secret. */
+export declare const ConnectionTarget: z.ZodString;

package/dist/node_modules/@agentorg/interfaces/dist/src/connection.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+/** A way a provider makes connections, such as `url` or `command`. */
+export const ConnectionKind = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]*$/)
+    .max(64);
+/** `connecting` before its first success, `connected`, or `down` and being tried again. */
+export const ConnectionState = z.enum(["connecting", "connected", "down"]);
+/** A connection's tools, for people to read; a provider cuts a long description to fit. */
+export const ConnectionTool = z.object({
+    name: z.string().min(1).max(128),
+    description: z.string().max(512).optional(),
+});
+/** How a connection stands now: `detail` says why it is down, and never holds a secret. */
+export const ConnectionStatus = z.object({
+    state: ConnectionState,
+    detail: z.string().max(2000).optional(),
+    tools: z.array(ConnectionTool),
+});
+/** The parameters of a connection, fitting its kind's `params` schema. */
+export const ConnectionParams = z.record(z.string(), z.json());
+/**
+ * What a server needs and shouldn't be seen, by name, such as a bearer token. Write-only: the values
+ * cross once, in `create`, and go only to the provider's own private file.
+ */
+export const ConnectionSecrets = z.record(z
+    .string()
+    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/)
+    .max(256), z.string().min(1).max(16_384));
+/** What a connection attaches to or runs, for people to read: never a secret. */
+export const ConnectionTarget = z.string().min(1).max(4096);

package/dist/node_modules/@agentorg/interfaces/dist/src/folders.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+/** The most folders one answer names. */
+export declare const FOLDERS_MAX = 2000;
+/**
+ * `folders@1`: the folders on the machine the app runs on, for a person choosing one. It names
+ * folders and nothing else. `list` starts at the person's home folder; `parent` is absent at the
+ * top. Refused `unknown` when there's no such folder, `invalid` for a path that isn't absolute.
+ */
+export declare const folders: import("@agentorg/sdk").RpcInterface<"folders", {
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        parent: z.ZodOptional<z.ZodString>;
+        folders: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, {}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/folders.js

@@ -0,0 +1,25 @@
+import { defineInterface, method } from "@agentorg/sdk";
+import { z } from "zod";
+/** The most folders one answer names. */
+export const FOLDERS_MAX = 2000;
+const Path = z.string().min(1).max(4096);
+/**
+ * `folders@1`: the folders on the machine the app runs on, for a person choosing one. It names
+ * folders and nothing else. `list` starts at the person's home folder; `parent` is absent at the
+ * top. Refused `unknown` when there's no such folder, `invalid` for a path that isn't absolute.
+ */
+export const folders = defineInterface({
+    name: "folders",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        list: method({
+            input: z.object({ path: Path.optional() }),
+            output: z.object({
+                path: Path,
+                parent: Path.optional(),
+                folders: z.array(z.object({ name: z.string().max(4096) })).max(FOLDERS_MAX),
+            }),
+        }),
+    },
+});

package/dist/node_modules/@agentorg/interfaces/dist/src/index.d.ts

@@ -1,10 +1,12 @@
 export { Account, accountLogin, LoginState } from "./account-login.js";
 export { AgentStatus, Answers, agentProvider, Creatable, CreatableId, } from "./agent-provider.js";
 export { agentSettings, SKILL_FILE_MAX, SkillEntry, SkillName, SkillPath, } from "./agent-settings.js";
-export { ChatMessage, ChatState, ChatStatus, ChatTool, chat } from "./chat.js";
-export { Actor, ActorState, AuditEntry, Binding, ExportEntry, hubActors, hubAudit, hubBindings, hubExports, hubGrants, } from "./hub.js";
+export { CHAT_TITLE_MAX, ChatEntry, ChatMessage, ChatStatus, ChatTool, chat, } from "./chat.js";
+export { ConnectionKind, ConnectionParams, ConnectionSecrets, ConnectionState, ConnectionStatus, ConnectionTarget, ConnectionTool, } from "./connection.js";
+export { FOLDERS_MAX, folders } from "./folders.js";
+export { Actor, ActorState, AuditEntry, Binding, ExportEntry, hubActors, hubAudit, hubBindings, hubExports, hubGrants, SlotName, } from "./hub.js";
 export { kv } from "./kv.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
-export { agents, ConnectionOrigin, connections, skills } from "./manager.js";
-export { ConnectionKind, ConnectionParams, ConnectionSecrets, ConnectionState, ConnectionStatus, ConnectionTarget, ConnectionTool, mcpProvider, } from "./mcp-provider.js";
+export { agents, ConnectionOrigin, connections, Stack, StackBase, StackUnit, skills, Template, TemplateId, } from "./manager.js";
 export { ToolEntry, tools } from "./tools.js";
+export { Field, FieldId, FieldValue, FieldValues, Form, LiveMode, LiveSurface, LiveTicket, Problem, ResultKind, Unit, UnitId, UnitResult, unitProvider, } from "./units.js";

package/dist/node_modules/@agentorg/interfaces/dist/src/index.js

@@ -1,10 +1,12 @@
 export { Account, accountLogin, LoginState } from "./account-login.js";
 export { AgentStatus, Answers, agentProvider, Creatable, CreatableId, } from "./agent-provider.js";
 export { agentSettings, SKILL_FILE_MAX, SkillEntry, SkillName, SkillPath, } from "./agent-settings.js";
-export { ChatMessage, ChatState, ChatStatus, ChatTool, chat } from "./chat.js";
-export { Actor, ActorState, AuditEntry, Binding, ExportEntry, hubActors, hubAudit, hubBindings, hubExports, hubGrants, } from "./hub.js";
+export { CHAT_TITLE_MAX, ChatEntry, ChatMessage, ChatStatus, ChatTool, chat, } from "./chat.js";
+export { ConnectionKind, ConnectionParams, ConnectionSecrets, ConnectionState, ConnectionStatus, ConnectionTarget, ConnectionTool, } from "./connection.js";
+export { FOLDERS_MAX, folders } from "./folders.js";
+export { Actor, ActorState, AuditEntry, Binding, ExportEntry, hubActors, hubAudit, hubBindings, hubExports, hubGrants, SlotName, } from "./hub.js";
 export { kv } from "./kv.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
-export { agents, ConnectionOrigin, connections, skills } from "./manager.js";
-export { ConnectionKind, ConnectionParams, ConnectionSecrets, ConnectionState, ConnectionStatus, ConnectionTarget, ConnectionTool, mcpProvider, } from "./mcp-provider.js";
+export { agents, ConnectionOrigin, connections, Stack, StackBase, StackUnit, skills, Template, TemplateId, } from "./manager.js";
 export { ToolEntry, tools } from "./tools.js";
+export { Field, FieldId, FieldValue, FieldValues, Form, LiveMode, LiveSurface, LiveTicket, Problem, ResultKind, Unit, UnitId, UnitResult, unitProvider, } from "./units.js";

package/dist/node_modules/@agentorg/interfaces/dist/src/llm-session.d.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+/** A model's id, as whoever offers the model names it. */
+export declare const ModelId: z.ZodString;
 /** One item of a conversation: what was said, a function the model called, and its output. */
 export declare const Item: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"message">;

package/dist/node_modules/@agentorg/interfaces/dist/src/llm-session.js

@@ -1,7 +1,8 @@
 import { defineInterface, event, method } from "@agentorg/sdk";
 import { z } from "zod";
 const RequestId = z.string().min(1).max(128);
-const ModelId = z.string().min(1).max(128);
+/** A model's id, as whoever offers the model names it. */
+export const ModelId = z.string().min(1).max(128);
 const CallId = z.string().min(1).max(256);
 /** A function tool's name, as the Responses API takes it. */
 const ToolName = z.string().regex(/^[A-Za-z0-9_-]{1,64}$/);