@jini-ai/agent-runtime 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Open Design contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,43 @@
+# `@jini/agent-runtime`
+
+Runtime-side content and execution code for agent-driven artifact
+generation: brand-agnostic craft knowledge and portable skill packages
+(both product-neutral per root `AGENTS.md`) plus a real TypeScript runtime
+surface — the `runtimes/` -> agent-runtime adapter registry/detection/
+launch/stream-parser port and the `agent-protocol/` ACP + pi-rpc subprocess
+transport (see `src/index.ts`'s own header comment and `source-map.md`'s
+"Barrel merge" section for the full inventory), plus `src/model-registry.ts`
+below. This top-level blurb has historically lagged that TS surface's
+growth — treat `src/index.ts` and `source-map.md` as the source of truth
+for what's actually implemented.
+
+## `src/model-registry.ts`
+
+The provider/model/agent-picker vocabulary (`ModelProvider`,
+`ModelCatalogOption` — exported as `ModelOption` is already taken by
+`agent-protocol/acp/models.ts`'s narrower ACP-probe shape —,
+`AgentDefinition`, `AgentDiagnostic`, `CredentialStatus`, ...) and a handful
+of pure helpers (credential-status resolution, model-list merging, a stable
+model-catalogue cache key, model-choice normalization against a live
+catalogue) for any consumer building a "pick a model/agent" UI — e.g.
+`@jini/chat-react`'s `features/model-picker/` slice. Distinct from
+`src/registry.ts` (the static `BASE_AGENT_DEFS` CLI-adapter catalog). See
+`source-map.md` for full provenance.
+
+## `src/craft/`
+
+Universal UI-craft rulebooks (typography, color, motion, accessibility,
+forms, RTL, anti-AI-slop, …) that a skill can opt into via a
+`craft.requires` front-matter array. See `src/craft/README.md` for the
+full mechanism and `source-map.md` for provenance.
+
+## `src/skills/`
+
+160 portable Skill packages ported from OD's 162-skill catalog (2 excluded
+as OD-internal — see `source-map.md`), each a `SKILL.md` + optional
+`assets/`/`scripts/`/`references/`. Frontmatter uses the same flat
+`craft.requires`/`design_system.requires`/`mode`/etc. key convention as
+`src/craft/`, not OD's original nested `od:` block. No TypeScript lives
+inside `src/skills/` itself — this directory is content only; the
+package's TypeScript runtime surface lives at `src/`'s top level, see
+above.

package/dist/acp-model-probe.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module acp-model-probe
+ *
+ * Port replacing OD's `detectAcpModels` import
+ * (`apps/daemon/src/acp.js`) inside `defs/shared.ts`. Eight of this
+ * package's def literals (devin, hermes, kilo, kimi, kiro, reasonix,
+ * trae-cli, vibe) fetch their live model list by speaking a session/new →
+ * session/list_models-shaped ACP JSON-RPC handshake to the spawned CLI.
+ *
+ * That handshake lives in OD's `acp.ts` (1744 lines) — the full ACP
+ * subprocess transport, which r1's recon classifies as its own separate
+ * GENERIC-ENGINE zone (`agent-protocol/`, 17 files) and a *later*
+ * extraction task, not this one. Porting it here would blow this task's
+ * scope far past "harvest wholesale" for what is genuinely a large,
+ * separate subsystem.
+ *
+ * So `detectAcpModels` becomes an injectable port: an `AcpModelProbe` with
+ * a single `detectModels(request)` method, matching the real call shape
+ * every ACP-based def literal already uses. The default implementation is
+ * a no-op that resolves to `[]`, which makes `detection.ts`'s `fetchModels`
+ * step treat the live-fetch as "returned nothing" and fall back to the
+ * def's static `fallbackModels` — the same behavior OD gets when the vela
+ * probe times out or errors. A future task that ports the ACP transport
+ * (or the OD adapter, sooner) calls `setAcpModelProbe()` once at startup to
+ * wire in the real implementation; every def literal that calls
+ * `detectAcpModels(...)` picks it up automatically, no per-def changes
+ * needed.
+ */
+import type { RuntimeEnv, RuntimeModelOption } from './types.js';
+export interface AcpModelProbeRequest {
+    bin: string;
+    args: string[];
+    cwd?: string;
+    env?: RuntimeEnv;
+    timeoutMs?: number;
+    clientName?: string;
+    clientVersion?: string;
+    defaultModelOption?: RuntimeModelOption;
+}
+export interface AcpModelProbe {
+    detectModels(request: AcpModelProbeRequest): Promise<RuntimeModelOption[]>;
+}
+export declare const noopAcpModelProbe: AcpModelProbe;
+/** Install the real ACP transport (or a test double). Pass `null` to restore the no-op default. */
+export declare function setAcpModelProbe(probe: AcpModelProbe | null): void;
+/** Drop-in replacement for OD's `detectAcpModels` — delegates to whatever probe is currently installed. */
+export declare function detectAcpModels(request: AcpModelProbeRequest): Promise<RuntimeModelOption[]>;
+//# sourceMappingURL=acp-model-probe.d.ts.map

package/dist/acp-model-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-model-probe.d.ts","sourceRoot":"","sources":["../src/acp-model-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;CAC5E;AAED,eAAO,MAAM,iBAAiB,EAAE,aAI/B,CAAC;AAIF,mGAAmG;AACnG,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAElE;AAED,2GAA2G;AAC3G,wBAAsB,eAAe,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAElG"}

package/dist/acp-model-probe.js

@@ -0,0 +1,15 @@
+export const noopAcpModelProbe = {
+    async detectModels() {
+        return [];
+    },
+};
+let activeAcpModelProbe = noopAcpModelProbe;
+/** Install the real ACP transport (or a test double). Pass `null` to restore the no-op default. */
+export function setAcpModelProbe(probe) {
+    activeAcpModelProbe = probe ?? noopAcpModelProbe;
+}
+/** Drop-in replacement for OD's `detectAcpModels` — delegates to whatever probe is currently installed. */
+export async function detectAcpModels(request) {
+    return activeAcpModelProbe.detectModels(request);
+}
+//# sourceMappingURL=acp-model-probe.js.map

package/dist/acp-model-probe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-model-probe.js","sourceRoot":"","sources":["../src/acp-model-probe.ts"],"names":[],"mappings":"AA6CA,MAAM,CAAC,MAAM,iBAAiB,GAAkB;IAC9C,KAAK,CAAC,YAAY;QAChB,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC;AAEF,IAAI,mBAAmB,GAAkB,iBAAiB,CAAC;AAE3D,mGAAmG;AACnG,MAAM,UAAU,gBAAgB,CAAC,KAA2B;IAC1D,mBAAmB,GAAG,KAAK,IAAI,iBAAiB,CAAC;AACnD,CAAC;AAED,2GAA2G;AAC3G,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,OAA6B;IACjE,OAAO,mBAAmB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;AACnD,CAAC"}

package/dist/agent-protocol/acp/account-failure.d.ts

@@ -0,0 +1,54 @@
+/** @module agent-protocol/acp/account-failure
+ * Injection seam for classifying agent-provider account-failure text (auth
+ * required, insufficient balance, quota exhausted, etc.) into a structured,
+ * actionable error. OD's real implementation classifies vela/AMR-branded
+ * failure text against a hardcoded, product-branded recharge URL — that
+ * adapter is product-specific and must not live in this package (see
+ * source-map.md for the full account of what was left behind and why).
+ * Callers inject their own `AccountFailureClassifier` through
+ * `AttachAcpSessionOptions.accountFailureClassifier`; the default
+ * `noopAccountFailureClassifier` always returns `null`, which reproduces the
+ * behavior of not having this feature at all — no promotion ever fires.
+ * Depends on nothing; consumed by acp/updates.ts and acp/session.ts.
+ */
+/**
+ * A structured, provider-agnostic account failure classification. Shaped
+ * generically (not AMR-specific field names) so any provider's classifier can
+ * satisfy this contract.
+ */
+export interface AccountFailure {
+    /** A stable machine-readable failure code (e.g. `'AUTH_REQUIRED'`). */
+    code: string;
+    /** A human-readable message describing the failure and how to recover. */
+    message: string;
+    /** The recovery action the caller should surface to the end user. */
+    action: string;
+    /** Optional URL to send the user to for taking `action` (e.g. a billing page). */
+    actionUrl?: string;
+}
+/**
+ * Injectable port: classifies free-form diagnostic text (drawn from an ACP
+ * session update or a stderr tail) into a structured `AccountFailure`, or
+ * `null` when the text does not match a known account-failure pattern.
+ */
+export interface AccountFailureClassifier {
+    classify(text: string): AccountFailure | null;
+}
+/**
+ * Default no-op classifier used when a caller does not inject a real one.
+ * Always returns `null`, meaning no account-failure promotion ever fires —
+ * identical observable behavior to not having the feature at all.
+ */
+export declare const noopAccountFailureClassifier: AccountFailureClassifier;
+/**
+ * Builds the `details` payload attached to a promoted account-failure error.
+ *
+ * @param failure - The classification result to describe.
+ * @returns A details object carrying `action` and, when present, `actionUrl`.
+ */
+export declare function accountFailureDetails(failure: AccountFailure): {
+    kind: 'account_failure';
+    action: string;
+    actionUrl?: string;
+};
+//# sourceMappingURL=account-failure.d.ts.map

package/dist/agent-protocol/acp/account-failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-failure.d.ts","sourceRoot":"","sources":["../../../src/agent-protocol/acp/account-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC;CAC/C;AAED;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,wBAI1C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,GAAG;IAC9D,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAMA"}

package/dist/agent-protocol/acp/account-failure.js

@@ -0,0 +1,37 @@
+/** @module agent-protocol/acp/account-failure
+ * Injection seam for classifying agent-provider account-failure text (auth
+ * required, insufficient balance, quota exhausted, etc.) into a structured,
+ * actionable error. OD's real implementation classifies vela/AMR-branded
+ * failure text against a hardcoded, product-branded recharge URL — that
+ * adapter is product-specific and must not live in this package (see
+ * source-map.md for the full account of what was left behind and why).
+ * Callers inject their own `AccountFailureClassifier` through
+ * `AttachAcpSessionOptions.accountFailureClassifier`; the default
+ * `noopAccountFailureClassifier` always returns `null`, which reproduces the
+ * behavior of not having this feature at all — no promotion ever fires.
+ * Depends on nothing; consumed by acp/updates.ts and acp/session.ts.
+ */
+/**
+ * Default no-op classifier used when a caller does not inject a real one.
+ * Always returns `null`, meaning no account-failure promotion ever fires —
+ * identical observable behavior to not having the feature at all.
+ */
+export const noopAccountFailureClassifier = {
+    classify() {
+        return null;
+    },
+};
+/**
+ * Builds the `details` payload attached to a promoted account-failure error.
+ *
+ * @param failure - The classification result to describe.
+ * @returns A details object carrying `action` and, when present, `actionUrl`.
+ */
+export function accountFailureDetails(failure) {
+    return {
+        kind: 'account_failure',
+        action: failure.action,
+        ...(failure.actionUrl ? { actionUrl: failure.actionUrl } : {}),
+    };
+}
+//# sourceMappingURL=account-failure.js.map

package/dist/agent-protocol/acp/account-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-failure.js","sourceRoot":"","sources":["../../../src/agent-protocol/acp/account-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA2BH;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAA6B;IACpE,QAAQ;QACN,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAuB;IAK3D,OAAO;QACL,IAAI,EAAE,iBAAiB;QACvB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC/D,CAAC;AACJ,CAAC"}

package/dist/agent-protocol/acp/constants.d.ts

@@ -0,0 +1,26 @@
+/** @module agent-protocol/acp/constants
+ * Protocol version, timeout defaults, artifact-detection patterns, and
+ * model-config identifier sets used across all acp/ files. No dependencies
+ * on other agent-protocol modules — safe to import from anywhere in acp/.
+ */
+/** ACP JSON-RPC protocol version sent in every `initialize` handshake. */
+export declare const ACP_PROTOCOL_VERSION = 1;
+/** Default timeout in milliseconds for short-lived ACP operations such as model detection. */
+export declare const DEFAULT_TIMEOUT_MS = 15000;
+/** Absolute upper ceiling for any ACP-derived timeout value (24 hours). */
+export declare const MAX_TIMEOUT_MS: number;
+/** Default per-stage inactivity watchdog timeout (10 minutes) for an ACP session; resets on every received line from the agent subprocess. */
+export declare const DEFAULT_STAGE_TIMEOUT_MS: number;
+/** Regex source fragment matching an opening DSML artifact or plain `artifact` tag in an ACP agent's text output. */
+export declare const ACP_ARTIFACT_OPEN_PATTERN: string;
+/** Regex source fragment matching agent preamble text like "here is the generated file:" that precedes an artifact open tag. */
+export declare const ACP_GENERATED_FILE_PREFIX_PATTERN: string;
+/** Compiled regex that detects the start of an ACP artifact echo in an `agent_message_chunk` delta; used to arm the DSML text suppressor. */
+export declare const ACP_ARTIFACT_ECHO_START_RE: RegExp;
+/** Maximum number of `acp_raw_event_shape` and `acp_artifact_text_suppression` diagnostic events emitted per session to avoid flooding the event stream. */
+export declare const ACP_RAW_EVENT_SHAPE_DIAGNOSTIC_LIMIT = 8;
+/** Maximum number of bytes retained from stderr to detect AMR retry/failure signals; older bytes are discarded to bound memory use. */
+export declare const AMR_STDERR_RETRY_TAIL_LIMIT = 16000;
+/** Normalised token IDs that identify a model-selection config option in an ACP `session/new` response's `configOptions` array. */
+export declare const MODEL_CONFIG_OPTION_IDS: Set<string>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/agent-protocol/acp/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/agent-protocol/acp/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,8FAA8F;AAC9F,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,2EAA2E;AAC3E,eAAO,MAAM,cAAc,QAAsB,CAAC;AAclD,8IAA8I;AAC9I,eAAO,MAAM,wBAAwB,QAAiB,CAAC;AACvD,qHAAqH;AACrH,eAAO,MAAM,yBAAyB,QAA4D,CAAC;AACnG,gIAAgI;AAChI,eAAO,MAAM,iCAAiC,QACmC,CAAC;AAClF,6IAA6I;AAC7I,eAAO,MAAM,0BAA0B,QAGtC,CAAC;AACF,4JAA4J;AAC5J,eAAO,MAAM,oCAAoC,IAAI,CAAC;AACtD,uIAAuI;AACvI,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAClD,mIAAmI;AACnI,eAAO,MAAM,uBAAuB,aAAsD,CAAC"}

package/dist/agent-protocol/acp/constants.js

@@ -0,0 +1,39 @@
+/** @module agent-protocol/acp/constants
+ * Protocol version, timeout defaults, artifact-detection patterns, and
+ * model-config identifier sets used across all acp/ files. No dependencies
+ * on other agent-protocol modules — safe to import from anywhere in acp/.
+ */
+/** ACP JSON-RPC protocol version sent in every `initialize` handshake. */
+export const ACP_PROTOCOL_VERSION = 1;
+/** Default timeout in milliseconds for short-lived ACP operations such as model detection. */
+export const DEFAULT_TIMEOUT_MS = 15_000;
+/** Absolute upper ceiling for any ACP-derived timeout value (24 hours). */
+export const MAX_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+// Gap-between-chunks watchdog for an ACP session stage. The timer resets on
+// every line received from the agent, so this bounds *silent* periods, not
+// total runtime. Default kept in line with a typical outer run-level
+// inactivity watchdog (10 min) so agents that spend several minutes silently
+// writing large artifacts do not get killed before that outer watchdog can
+// apply. Callers can override via `stageTimeoutMs`; a host application may
+// resolve its own branded environment variable to a value it passes in here
+// (this package does not read any env var directly for this default).
+// A non-positive `stageTimeoutMs` (`<= 0`) disables the watchdog entirely,
+// mirroring a typical outer run-level watchdog's escape-hatch semantics —
+// without this, a caller passing `stageTimeoutMs: 0` would call
+// `setTimeout(..., 0)` and fail every ACP session on the next tick instead of
+// disabling the watchdog.
+/** Default per-stage inactivity watchdog timeout (10 minutes) for an ACP session; resets on every received line from the agent subprocess. */
+export const DEFAULT_STAGE_TIMEOUT_MS = 10 * 60 * 1000;
+/** Regex source fragment matching an opening DSML artifact or plain `artifact` tag in an ACP agent's text output. */
+export const ACP_ARTIFACT_OPEN_PATTERN = String.raw `<\s*(?:\|?\s*DSML[\s,]+artifact\b|artifact\b)`;
+/** Regex source fragment matching agent preamble text like "here is the generated file:" that precedes an artifact open tag. */
+export const ACP_GENERATED_FILE_PREFIX_PATTERN = String.raw `(?:here\s+is|here'?s)\s+the\s+generated\s+file\s*:?\s*(?:\r?\n|\s)*`;
+/** Compiled regex that detects the start of an ACP artifact echo in an `agent_message_chunk` delta; used to arm the DSML text suppressor. */
+export const ACP_ARTIFACT_ECHO_START_RE = new RegExp(String.raw `^\s*(?:${ACP_ARTIFACT_OPEN_PATTERN}|${ACP_GENERATED_FILE_PREFIX_PATTERN}${ACP_ARTIFACT_OPEN_PATTERN})`, 'i');
+/** Maximum number of `acp_raw_event_shape` and `acp_artifact_text_suppression` diagnostic events emitted per session to avoid flooding the event stream. */
+export const ACP_RAW_EVENT_SHAPE_DIAGNOSTIC_LIMIT = 8;
+/** Maximum number of bytes retained from stderr to detect AMR retry/failure signals; older bytes are discarded to bound memory use. */
+export const AMR_STDERR_RETRY_TAIL_LIMIT = 16_000;
+/** Normalised token IDs that identify a model-selection config option in an ACP `session/new` response's `configOptions` array. */
+export const MODEL_CONFIG_OPTION_IDS = new Set(['model', 'models', 'modelid', 'modelids']);
+//# sourceMappingURL=constants.js.map

package/dist/agent-protocol/acp/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/agent-protocol/acp/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0EAA0E;AAC1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AACtC,8FAA8F;AAC9F,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AACzC,2EAA2E;AAC3E,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAClD,4EAA4E;AAC5E,2EAA2E;AAC3E,qEAAqE;AACrE,6EAA6E;AAC7E,2EAA2E;AAC3E,2EAA2E;AAC3E,4EAA4E;AAC5E,sEAAsE;AACtE,2EAA2E;AAC3E,0EAA0E;AAC1E,gEAAgE;AAChE,8EAA8E;AAC9E,0BAA0B;AAC1B,8IAA8I;AAC9I,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AACvD,qHAAqH;AACrH,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAA,+CAA+C,CAAC;AACnG,gIAAgI;AAChI,MAAM,CAAC,MAAM,iCAAiC,GAC5C,MAAM,CAAC,GAAG,CAAA,qEAAqE,CAAC;AAClF,6IAA6I;AAC7I,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAI,MAAM,CAClD,MAAM,CAAC,GAAG,CAAA,UAAU,yBAAyB,IAAI,iCAAiC,GAAG,yBAAyB,GAAG,EACjH,GAAG,CACJ,CAAC;AACF,4JAA4J;AAC5J,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAAC,CAAC;AACtD,uIAAuI;AACvI,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC;AAClD,mIAAmI;AACnI,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC"}

package/dist/agent-protocol/acp/index.d.ts

@@ -0,0 +1,14 @@
+/** @module agent-protocol/acp
+ * Public barrel for the ACP (Agent Client Protocol) JSON-RPC subprocess
+ * transport. Re-exports the surface consumed by runtime adapter definitions
+ * (detectAcpModels, normalizeModels, ModelOption), a host's connection-test
+ * and chat-server entry points (attachAcpSession, buildAcpSessionNewParams,
+ * AcpMcpServerInput), and the account-failure injection seam
+ * (AccountFailure, AccountFailureClassifier, noopAccountFailureClassifier) a
+ * host application uses to plug in its own provider-specific classifier.
+ */
+export { type AcpMcpServerInput, buildAcpSessionNewParams } from './session-params.js';
+export { type ModelOption, normalizeModels, detectAcpModels } from './models.js';
+export { attachAcpSession, type AcpPermissionDecision, type AcpPermissionHandler, type AcpPermissionOption, type AcpPermissionRequest, type AcpSessionController, type AttachAcpSessionOptions, } from './session.js';
+export { type AccountFailure, type AccountFailureClassifier, noopAccountFailureClassifier, } from './account-failure.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agent-protocol/acp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agent-protocol/acp/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,KAAK,WAAW,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,GAC7B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC"}

package/dist/agent-protocol/acp/index.js

@@ -0,0 +1,14 @@
+/** @module agent-protocol/acp
+ * Public barrel for the ACP (Agent Client Protocol) JSON-RPC subprocess
+ * transport. Re-exports the surface consumed by runtime adapter definitions
+ * (detectAcpModels, normalizeModels, ModelOption), a host's connection-test
+ * and chat-server entry points (attachAcpSession, buildAcpSessionNewParams,
+ * AcpMcpServerInput), and the account-failure injection seam
+ * (AccountFailure, AccountFailureClassifier, noopAccountFailureClassifier) a
+ * host application uses to plug in its own provider-specific classifier.
+ */
+export { buildAcpSessionNewParams } from './session-params.js';
+export { normalizeModels, detectAcpModels } from './models.js';
+export { attachAcpSession, } from './session.js';
+export { noopAccountFailureClassifier, } from './account-failure.js';
+//# sourceMappingURL=index.js.map

package/dist/agent-protocol/acp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/agent-protocol/acp/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAA0B,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAoB,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EACL,gBAAgB,GAOjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAGL,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC"}

package/dist/agent-protocol/acp/json.d.ts

@@ -0,0 +1,82 @@
+/** @module agent-protocol/acp/json
+ * Pure JSON value-extraction and text-traversal helpers for the ACP layer,
+ * plus the ACP timeout environment resolver. Has no side effects and
+ * performs no I/O; depends only on acp/types and acp/constants.
+ * Consumed by acp/rpc.ts, acp/session.ts, acp/models.ts, and acp/updates.ts.
+ */
+import type { JsonObject } from './types.js';
+/** Default environment variable name `resolveAcpTimeoutMs` reads when the
+ * caller does not supply its own. A host application with its own branded
+ * env var naming convention should pass its own name explicitly rather than
+ * rely on this default. */
+export declare const DEFAULT_ACP_TIMEOUT_ENV_VAR = "AGENT_RUNTIME_ACP_TIMEOUT_MS";
+/**
+ * Extracts a human-readable error message from an unknown thrown value.
+ * Returns `err.message` for `Error` instances, `String(err)` otherwise.
+ *
+ * @param err - Any caught value (typically an `Error` but may be anything).
+ */
+export declare function errorMessage(err: unknown): string;
+/**
+ * Resolves the effective ACP timeout from an environment variable, falling
+ * back to `fallbackMs` when the variable is absent or non-finite. Clamps the
+ * result to `[0, MAX_TIMEOUT_MS]`.
+ *
+ * @param env - The process environment object to read the timeout var from.
+ * @param fallbackMs - The default timeout to use when the env var is unset.
+ * @param envVarName - The environment variable name to read. Defaults to
+ *   `DEFAULT_ACP_TIMEOUT_ENV_VAR`; a host application may pass its own
+ *   branded name (its own `<PRODUCT>_ACP_TIMEOUT_MS`-style variable) here
+ *   without this package hardcoding any one product's naming convention.
+ * @returns The resolved timeout in milliseconds.
+ */
+export declare function resolveAcpTimeoutMs(env: NodeJS.ProcessEnv, fallbackMs: number, envVarName?: string): number;
+/**
+ * Coerces an unknown value to a `JsonObject` if it is a non-null, non-array
+ * plain object, or returns `null` otherwise. The primary guard used throughout
+ * the ACP layer before accessing named properties on parsed JSON frames.
+ *
+ * @param value - Any value from a JSON parse result.
+ * @returns The value cast as `JsonObject`, or `null` when the cast is unsafe.
+ */
+export declare function asObject(value: unknown): JsonObject | null;
+/**
+ * Returns a short diagnostic string describing the JSON kind of `value`:
+ * `'array'`, `'null'`, or the result of `typeof`. Used to build
+ * `acp_raw_event_shape` diagnostics without touching the value.
+ *
+ * @param value - Any value from a parsed ACP update object.
+ */
+export declare function acpValueKind(value: unknown): string;
+/**
+ * Returns a sorted array of own string keys from `value` if it is a
+ * `JsonObject`, or an empty array otherwise. Used to snapshot object
+ * structure for diagnostic payloads without risking a throw.
+ *
+ * @param value - Any value from a parsed ACP update object.
+ */
+export declare function objectKeys(value: unknown): string[];
+/**
+ * Recursively traverses an ACP update value up to 4 levels deep and returns
+ * the first non-empty string found, checking common text-bearing keys in order:
+ * `text`, `delta`, `content`, `message`, `output`, `answer`, `value`, `body`,
+ * `parts`, `choices`. Handles string scalars, flat arrays, and nested objects.
+ *
+ * Used as the extraction primitive by `extractAcpUpdateText`.
+ *
+ * @param value - A value from a parsed ACP session update.
+ * @param depth - Current recursion depth (max 4); callers omit this.
+ * @returns The first non-empty string found, or `null` when none is present.
+ */
+export declare function extractAcpTextValue(value: unknown, depth?: number): string | null;
+/**
+ * Extracts the first non-empty text string from the top-level properties of a
+ * parsed ACP session update object. Checks the same key list as
+ * `extractAcpTextValue` but at only one level of depth (the update object
+ * itself), delegating deep traversal to that helper.
+ *
+ * @param update - A parsed ACP `session/update` params object.
+ * @returns The first non-empty text string, or `null` when none is present.
+ */
+export declare function extractAcpUpdateText(update: JsonObject): string | null;
+//# sourceMappingURL=json.d.ts.map

package/dist/agent-protocol/acp/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/agent-protocol/acp/json.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;2BAG2B;AAC3B,eAAO,MAAM,2BAA2B,iCAAiC,CAAC;AAE1E;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAEjD;AACD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,MAAoC,GAC/C,MAAM,CAIR;AACD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAE1D;AACD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAInD;AACD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAGnD;AACD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,MAAM,GAAG,IAAI,CA4B5E;AACD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAiBtE"}