@jini-ai/daemon 0.2.1 → 0.3.0

package/dist/tool-result-media.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Extracts UI-renderable media blocks from a tool handler's raw MCP-style content envelope
+ * (`{ content: [...] }`), for `delegated-tool-bridge.ts` and `agent-executor.ts` to attach to the
+ * `tool_result` wire event's new `media` field (`@jini-ai/protocol`'s `events.ts`).
+ *
+ * ## Why this is not `tool-result-surfaces.ts`
+ *
+ * That module's whitelist governs a SECURITY property: which blocks may reach the model versus
+ * which are withheld for a human-only UI resource (MCP-UI, still deferred). This module answers a
+ * different question — "does this block carry displayable media a chat pane can render inline" —
+ * and is deliberately narrower: it recognizes exactly one block type today (`image`), and has no
+ * withhold-from-model concept of its own.
+ *
+ * The two DO interact, though not by pipelining: `delegated-tool-bridge.ts`'s `execute()` calls both
+ * of them against the SAME raw `executed.output`, not this module's `remainder` into
+ * `splitToolResultSurfaces`. That used to be pipelined — this module removed recognized image
+ * blocks from `content` before the surfaces pass ran, because `splitToolResultSurfaces`'s whitelist
+ * used to recognize only `text`, and an image block left in place would have been swept into
+ * `surfaces` and withheld from the model. Now that `image` is itself one of
+ * `tool-result-surfaces.ts`'s `MODEL_VISIBLE_BLOCK_TYPES` (a deliberate addition — see that
+ * constant's own doc), the surfaces pass classifies an image block correctly on its own, so there is
+ * no misclassification left to prevent by removing it first. This module's `remainder` field is
+ * therefore no longer read by that caller at all (kept for this module's own tests and any future
+ * caller that wants a de-imaged copy); only `media` is used, to populate the `tool_result` event's
+ * sibling `media` field for a UI that wants to render inline without re-parsing `content`.
+ *
+ * ## Why only `image`, and why blocks are silently skipped rather than reported
+ *
+ * `text` blocks already reach the model (and the UI, via `content`) through the existing flattened
+ * string — duplicating them into `media` would be redundant, not additive, so this module leaves
+ * them in `remainder` and never collects them. A block claiming `type: 'image'` without a string
+ * `mimeType`/`data` is dropped rather than surfaced as a malformed-block error: a handler's return
+ * value is untrusted input to this module (it may come from an external MCP server), and the
+ * contract is "render what is well-formed, ignore what isn't" — the same fail-quiet posture
+ * `serializeDelegatedToolOutput` already takes on a non-serializable output.
+ */
+/** One MCP-style text content block. Part of the recognized envelope shape but never collected —
+ *  see this module's doc for why `text` blocks stay out of `media`. Exported so a caller narrowing
+ *  `ToolResultMediaBlock.type` has both arms of the union in scope. */
+export interface ToolResultTextBlock {
+    readonly type: 'text';
+    readonly text: string;
+}
+/** One MCP-style image content block — the one block type this slice proves end to end.
+ *  `mimeType`/`data` mirror MCP's own `ImageContent` field names deliberately, so a block copied
+ *  verbatim out of an MCP tool result already matches this shape with no field renaming. */
+export interface ToolResultImageBlock {
+    readonly type: 'image';
+    /** IANA media type, e.g. `"image/png"`. */
+    readonly mimeType: string;
+    /** Base64-encoded image bytes. */
+    readonly data: string;
+}
+/** A tool result content block `media` may carry. Modeled on MCP's own content-block vocabulary —
+ *  see this module's doc for why that vocabulary is reused rather than a fourth one invented. */
+export type ToolResultMediaBlock = ToolResultTextBlock | ToolResultImageBlock;
+export interface ExtractResultMedia {
+    /**
+     * `output` with every recognized image block removed from its `content` array. Identical
+     * reference to the input when nothing was extracted (not an envelope, no `content` array, or no
+     * well-formed `image` blocks) — mirrors `tool-result-surfaces.ts`'s `SplitToolResultSurfaces`
+     * same-reference contract for the common no-op case.
+     */
+    readonly remainder: unknown;
+    /** Recognized image blocks, in arrival order. Empty when nothing was extracted. */
+    readonly media: readonly ToolResultMediaBlock[];
+}
+/**
+ * Splits a tool handler's raw return value into its recognized media blocks and the remainder,
+ * ready to feed onward into `splitToolResultSurfaces` (see this module's doc for why that order
+ * matters).
+ *
+ * @param output - A tool handler's raw return value (`ToolExecutionResult.output` when
+ * `status === 'completed'`). Non-envelope values (the overwhelming majority of tools, which return
+ * plain JSON) pass through untouched with no media.
+ * @complexity O(n) in the number of content blocks.
+ */
+export declare function extractResultMedia(output: unknown): ExtractResultMedia;
+//# sourceMappingURL=tool-result-media.d.ts.map

package/dist/tool-result-media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-media.d.ts","sourceRoot":"","sources":["../src/tool-result-media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;uEAEuE;AACvE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;4FAE4F;AAC5F,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,kCAAkC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;iGACiG;AACjG,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG,oBAAoB,CAAC;AAE9E,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACjD;AAgBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAetE"}

package/dist/tool-result-media.js

@@ -0,0 +1,80 @@
+/**
+ * Extracts UI-renderable media blocks from a tool handler's raw MCP-style content envelope
+ * (`{ content: [...] }`), for `delegated-tool-bridge.ts` and `agent-executor.ts` to attach to the
+ * `tool_result` wire event's new `media` field (`@jini-ai/protocol`'s `events.ts`).
+ *
+ * ## Why this is not `tool-result-surfaces.ts`
+ *
+ * That module's whitelist governs a SECURITY property: which blocks may reach the model versus
+ * which are withheld for a human-only UI resource (MCP-UI, still deferred). This module answers a
+ * different question — "does this block carry displayable media a chat pane can render inline" —
+ * and is deliberately narrower: it recognizes exactly one block type today (`image`), and has no
+ * withhold-from-model concept of its own.
+ *
+ * The two DO interact, though not by pipelining: `delegated-tool-bridge.ts`'s `execute()` calls both
+ * of them against the SAME raw `executed.output`, not this module's `remainder` into
+ * `splitToolResultSurfaces`. That used to be pipelined — this module removed recognized image
+ * blocks from `content` before the surfaces pass ran, because `splitToolResultSurfaces`'s whitelist
+ * used to recognize only `text`, and an image block left in place would have been swept into
+ * `surfaces` and withheld from the model. Now that `image` is itself one of
+ * `tool-result-surfaces.ts`'s `MODEL_VISIBLE_BLOCK_TYPES` (a deliberate addition — see that
+ * constant's own doc), the surfaces pass classifies an image block correctly on its own, so there is
+ * no misclassification left to prevent by removing it first. This module's `remainder` field is
+ * therefore no longer read by that caller at all (kept for this module's own tests and any future
+ * caller that wants a de-imaged copy); only `media` is used, to populate the `tool_result` event's
+ * sibling `media` field for a UI that wants to render inline without re-parsing `content`.
+ *
+ * ## Why only `image`, and why blocks are silently skipped rather than reported
+ *
+ * `text` blocks already reach the model (and the UI, via `content`) through the existing flattened
+ * string — duplicating them into `media` would be redundant, not additive, so this module leaves
+ * them in `remainder` and never collects them. A block claiming `type: 'image'` without a string
+ * `mimeType`/`data` is dropped rather than surfaced as a malformed-block error: a handler's return
+ * value is untrusted input to this module (it may come from an external MCP server), and the
+ * contract is "render what is well-formed, ignore what isn't" — the same fail-quiet posture
+ * `serializeDelegatedToolOutput` already takes on a non-serializable output.
+ */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Narrows one loosely-typed content-array entry to a well-formed {@link ToolResultImageBlock}, or
+ *  `undefined` for anything else (wrong `type`, or a `type: 'image'` block missing/mistyping
+ *  `mimeType`/`data`). */
+function asImageBlock(block) {
+    if (!isRecord(block) || block['type'] !== 'image')
+        return undefined;
+    const { mimeType, data } = block;
+    if (typeof mimeType !== 'string' || typeof data !== 'string')
+        return undefined;
+    return { type: 'image', mimeType, data };
+}
+/**
+ * Splits a tool handler's raw return value into its recognized media blocks and the remainder,
+ * ready to feed onward into `splitToolResultSurfaces` (see this module's doc for why that order
+ * matters).
+ *
+ * @param output - A tool handler's raw return value (`ToolExecutionResult.output` when
+ * `status === 'completed'`). Non-envelope values (the overwhelming majority of tools, which return
+ * plain JSON) pass through untouched with no media.
+ * @complexity O(n) in the number of content blocks.
+ */
+export function extractResultMedia(output) {
+    if (!isRecord(output))
+        return { remainder: output, media: [] };
+    const content = output['content'];
+    if (!Array.isArray(content))
+        return { remainder: output, media: [] };
+    const media = [];
+    const kept = [];
+    for (const entry of content) {
+        const image = asImageBlock(entry);
+        if (image)
+            media.push(image);
+        else
+            kept.push(entry);
+    }
+    if (media.length === 0)
+        return { remainder: output, media: [] };
+    return { remainder: { ...output, content: kept }, media };
+}
+//# sourceMappingURL=tool-result-media.js.map

package/dist/tool-result-media.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-media.js","sourceRoot":"","sources":["../src/tool-result-media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAqCH,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED;;0BAE0B;AAC1B,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,OAAO;QAAE,OAAO,SAAS,CAAC;IACpE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;IACjC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAC/E,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC3C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IAC/D,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IAErE,MAAM,KAAK,GAA2B,EAAE,CAAC;IACzC,MAAM,IAAI,GAAc,EAAE,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,KAAK;YAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;;YACxB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IAChE,OAAO,EAAE,SAAS,EAAE,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC;AAC5D,CAAC"}

package/dist/tool-result-surfaces.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Splits a tool handler's return value into the part the MODEL may see and the parts only a HUMAN
+ * may see.
+ *
+ * ## Why this exists
+ *
+ * MCP's own model is that a tool result carries content blocks and the *host* decides which blocks
+ * reach the model and which are rendered for the person. Keeping them in one payload is the
+ * protocol; separating them is the host's job. Jini's daemon is the only actor standing in that
+ * position — the spawned coding-agent CLI is not an MCP-UI host, and `okResult()`
+ * (`@jini-ai/mcp`'s `tool-protocol.ts`) `JSON.stringify`s whatever it is handed into a single text
+ * block. So a UI resource left in a handler's return value becomes ordinary model-visible context.
+ *
+ * That is not hypothetical. A host's `content_post_delete` tool returned
+ * `{ content: [textBlock, uiResource] }` where the resource's inline `<script>` held a single-use
+ * confirmation token, and the tool's own description told the model the token "is never shown to
+ * you". The model could read it out of its own tool result and approve its own deletion. The split
+ * this module performs is what makes that structurally impossible.
+ *
+ * ## Whitelist, not blacklist — the security boundary
+ *
+ * {@link splitToolResultSurfaces} does NOT look for known UI shapes and strip them. It keeps only
+ * block types explicitly known to be model-safe (`text`) and routes **everything else** to the
+ * human channel, including block types that did not exist when this was written.
+ *
+ * The direction of that default is the whole point. A blacklist fails OPEN: the first time the
+ * MCP-UI spec adds a block type this file has never heard of, an unrecognised block sails through
+ * into model context — exactly the leak being fixed, reintroduced silently. A whitelist fails
+ * CLOSED: an unrecognised block is withheld from the model and rendered for the human, so the worst
+ * case is a surface that renders oddly rather than a secret that escapes.
+ *
+ * **Do not "improve" this by enumerating UI types to remove.** If a new block type is genuinely
+ * model-safe, add it to {@link MODEL_VISIBLE_BLOCK_TYPES} deliberately, with a reason.
+ *
+ * ## What is deliberately left alone
+ *
+ * A return value that is not an MCP content envelope (`{ content: [...] }`) passes through
+ * untouched. The overwhelming majority of registered tools return plain JSON — a list of posts, an
+ * id, a count — and are not making a model-vs-human distinction at all. Rewriting those would be a
+ * behavioural change to every tool in the registry in service of a problem they do not have.
+ */
+/**
+ * Block `type` values a tool result may show the model.
+ *
+ * `text` and `image`, deliberately so — see this module's header before adding to it. `image` was
+ * added rather than left to the fail-closed default because it is genuinely model-safe in a way an
+ * MCP-UI resource is not: `ImageContent` is MCP's own vision-input mechanism, defined exactly so a
+ * tool result can put picture bytes in front of the model (`assistant_demo_image`'s whole reason to
+ * exist, in Tovu, is proving that round trip). That is a different property from "renders a UI a
+ * human clicks" — an image block carries no interactive surface and no host-side secret the way an
+ * embedded confirmation dialog can, so withholding it here would not close a leak, it would just
+ * break the feature. Anything else absent from this list is still treated as human-only.
+ */
+export declare const MODEL_VISIBLE_BLOCK_TYPES: readonly string[];
+/** One entry of an MCP tool result's `content` array. Structure beyond `type` is not this module's business. */
+export type ToolResultBlock = Record<string, unknown>;
+export interface SplitToolResultSurfaces {
+    /**
+     * What may be returned to the caller and therefore reach the model. Identical to the input
+     * (same reference) when the value is not an MCP content envelope.
+     */
+    readonly modelOutput: unknown;
+    /**
+     * Blocks withheld from the model, in arrival order, for the host to render to the human. Empty
+     * when nothing was withheld — the common case.
+     */
+    readonly surfaces: readonly ToolResultBlock[];
+}
+/**
+ * Partitions an MCP content envelope into model-visible and human-only halves.
+ *
+ * @param output - A tool handler's raw return value.
+ * @returns `modelOutput` (safe to return to the agent) and `surfaces` (human-only blocks). A
+ *   non-envelope value is passed through by reference with no surfaces.
+ * @complexity O(n) in the number of content blocks.
+ */
+export declare function splitToolResultSurfaces(output: unknown): SplitToolResultSurfaces;
+//# sourceMappingURL=tool-result-surfaces.d.ts.map

package/dist/tool-result-surfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-surfaces.d.ts","sourceRoot":"","sources":["../src/tool-result-surfaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,MAAM,EAAsB,CAAC;AAE9E,gHAAgH;AAChH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtD,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CAC/C;AAMD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,uBAAuB,CA2BhF"}

package/dist/tool-result-surfaces.js

@@ -0,0 +1,92 @@
+/**
+ * Splits a tool handler's return value into the part the MODEL may see and the parts only a HUMAN
+ * may see.
+ *
+ * ## Why this exists
+ *
+ * MCP's own model is that a tool result carries content blocks and the *host* decides which blocks
+ * reach the model and which are rendered for the person. Keeping them in one payload is the
+ * protocol; separating them is the host's job. Jini's daemon is the only actor standing in that
+ * position — the spawned coding-agent CLI is not an MCP-UI host, and `okResult()`
+ * (`@jini-ai/mcp`'s `tool-protocol.ts`) `JSON.stringify`s whatever it is handed into a single text
+ * block. So a UI resource left in a handler's return value becomes ordinary model-visible context.
+ *
+ * That is not hypothetical. A host's `content_post_delete` tool returned
+ * `{ content: [textBlock, uiResource] }` where the resource's inline `<script>` held a single-use
+ * confirmation token, and the tool's own description told the model the token "is never shown to
+ * you". The model could read it out of its own tool result and approve its own deletion. The split
+ * this module performs is what makes that structurally impossible.
+ *
+ * ## Whitelist, not blacklist — the security boundary
+ *
+ * {@link splitToolResultSurfaces} does NOT look for known UI shapes and strip them. It keeps only
+ * block types explicitly known to be model-safe (`text`) and routes **everything else** to the
+ * human channel, including block types that did not exist when this was written.
+ *
+ * The direction of that default is the whole point. A blacklist fails OPEN: the first time the
+ * MCP-UI spec adds a block type this file has never heard of, an unrecognised block sails through
+ * into model context — exactly the leak being fixed, reintroduced silently. A whitelist fails
+ * CLOSED: an unrecognised block is withheld from the model and rendered for the human, so the worst
+ * case is a surface that renders oddly rather than a secret that escapes.
+ *
+ * **Do not "improve" this by enumerating UI types to remove.** If a new block type is genuinely
+ * model-safe, add it to {@link MODEL_VISIBLE_BLOCK_TYPES} deliberately, with a reason.
+ *
+ * ## What is deliberately left alone
+ *
+ * A return value that is not an MCP content envelope (`{ content: [...] }`) passes through
+ * untouched. The overwhelming majority of registered tools return plain JSON — a list of posts, an
+ * id, a count — and are not making a model-vs-human distinction at all. Rewriting those would be a
+ * behavioural change to every tool in the registry in service of a problem they do not have.
+ */
+/**
+ * Block `type` values a tool result may show the model.
+ *
+ * `text` and `image`, deliberately so — see this module's header before adding to it. `image` was
+ * added rather than left to the fail-closed default because it is genuinely model-safe in a way an
+ * MCP-UI resource is not: `ImageContent` is MCP's own vision-input mechanism, defined exactly so a
+ * tool result can put picture bytes in front of the model (`assistant_demo_image`'s whole reason to
+ * exist, in Tovu, is proving that round trip). That is a different property from "renders a UI a
+ * human clicks" — an image block carries no interactive surface and no host-side secret the way an
+ * embedded confirmation dialog can, so withholding it here would not close a leak, it would just
+ * break the feature. Anything else absent from this list is still treated as human-only.
+ */
+export const MODEL_VISIBLE_BLOCK_TYPES = ['text', 'image'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Partitions an MCP content envelope into model-visible and human-only halves.
+ *
+ * @param output - A tool handler's raw return value.
+ * @returns `modelOutput` (safe to return to the agent) and `surfaces` (human-only blocks). A
+ *   non-envelope value is passed through by reference with no surfaces.
+ * @complexity O(n) in the number of content blocks.
+ */
+export function splitToolResultSurfaces(output) {
+    if (!isRecord(output))
+        return { modelOutput: output, surfaces: [] };
+    const content = output['content'];
+    if (!Array.isArray(content))
+        return { modelOutput: output, surfaces: [] };
+    const modelBlocks = [];
+    const surfaces = [];
+    for (const block of content) {
+        // A non-record block carries no `type` to check, so it cannot be shown to be model-safe.
+        // Withheld rather than passed through, per this module's fail-closed rule.
+        if (!isRecord(block)) {
+            surfaces.push({ type: 'unknown', value: block });
+            continue;
+        }
+        const type = block['type'];
+        if (typeof type === 'string' && MODEL_VISIBLE_BLOCK_TYPES.includes(type)) {
+            modelBlocks.push(block);
+            continue;
+        }
+        surfaces.push(block);
+    }
+    if (surfaces.length === 0)
+        return { modelOutput: output, surfaces: [] };
+    return { modelOutput: { ...output, content: modelBlocks }, surfaces };
+}
+//# sourceMappingURL=tool-result-surfaces.js.map

package/dist/tool-result-surfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-surfaces.js","sourceRoot":"","sources":["../src/tool-result-surfaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAsB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAkB9E,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAAe;IACrD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAEpE,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAE1E,MAAM,WAAW,GAAc,EAAE,CAAC;IAClC,MAAM,QAAQ,GAAsB,EAAE,CAAC;IAEvC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,yFAAyF;QACzF,2EAA2E;QAC3E,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YACjD,SAAS;QACX,CAAC;QACD,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,yBAAyB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACzE,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxB,SAAS;QACX,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAExE,OAAO,EAAE,WAAW,EAAE,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,CAAC;AACxE,CAAC"}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@jini-ai/daemon",
-  "version": "0.2.1",
+  "version": "0.3.0",
+  "description": "The stateful agent daemon runtime: run lifecycle, durable event-log port, the tool-execution boundary, agent executor, terminal sessions, and routines.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -10,10 +11,10 @@
   "jini": {
     "domain": "server",
     "kind": "runtime",
-    "runtime": "node",
-    "admission": "locked"
+    "runtime": "node"
   },
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -36,14 +37,22 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "node-pty": "^1.1.0",
-    "@jini-ai/core": "0.1.2",
-    "@jini-ai/platform": "0.1.2",
-    "@jini-ai/agent-runtime": "0.2.1",
-    "@jini-ai/protocol": "0.1.2"
+    "@jini-ai/core": "0.3.0",
+    "@jini-ai/platform": "0.3.0",
+    "@jini-ai/agent-runtime": "0.3.0",
+    "@jini-ai/protocol": "0.3.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^2.1.9"
+    "@vitest/coverage-v8": "^2.1.9",
+    "node-pty": "^1.1.0"
+  },
+  "peerDependencies": {
+    "node-pty": "^1.1.0"
+  },
+  "peerDependenciesMeta": {
+    "node-pty": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",