@try-works/dsh-model-as-tool 0.1.3 → 0.3.6

package/node_modules/@try-works/tool-mode-extension-sdk/lib/runtime.d.ts

@@ -0,0 +1,242 @@
+/**
+ * The public extension runtime API (EXT-17, EXT-18, EXT-19).
+ *
+ * These are the interfaces an extension author implements and a host calls. The
+ * SDK owns them because an author must be able to build and test against them
+ * WITHOUT DSH or the Tool Mode host present (EXT-02): an extension that imported
+ * host internals would be unbuildable for anyone who has not installed the host,
+ * and would break on every host refactor.
+ *
+ * The context objects are deliberately narrow. `ExtensionContextV1` carries no
+ * DSH `ctx`, no registry mutation, no global credentials and no unfiltered
+ * environment; `InvocationContextV1` carries no caller-supplied authority and no
+ * arbitrary tool dispatch. An extension that needs a file or a secret asks the
+ * host through a broker whose grants are the operator's, not the extension's.
+ *
+ * @module @try-works/tool-mode-extension-sdk/runtime
+ */
+import type { ModelReadiness } from './state.ts';
+/** A lossless JSON value. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** A lossless JSON object, the shape every request and result uses. */
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** Why an extension is being disposed. */
+export type DisposeReason = 'deactivate' | 'upgrade' | 'uninstall' | 'shutdown' | 'fault';
+/** A bounded diagnostic logger. It carries no credentials and cannot be silenced upward. */
+export interface ExtensionLoggerV1 {
+    /**
+     * Record a diagnostic.
+     * @param level - severity.
+     * @param message - what happened. Must not contain secrets.
+     * @param fields - bounded structured detail.
+     */
+    log(level: 'debug' | 'info' | 'warn' | 'error', message: string, fields?: JsonObject): void;
+}
+/**
+ * Extension-private storage.
+ *
+ * Private means private to the extension across its own calls; it is not a shared
+ * scratch space and not a route to the operator's filesystem.
+ */
+export interface ExtensionStorageV1 {
+    /**
+     * Read a value.
+     * @param key - the key.
+     * @returns the stored value, or undefined.
+     */
+    read(key: string): Promise<JsonValue | undefined>;
+    /**
+     * Write a value.
+     * @param key - the key.
+     * @param value - the value to store.
+     */
+    write(key: string, value: JsonValue): Promise<void>;
+    /** Absolute path this extension may use for private files. */
+    readonly directory: string;
+}
+/** Host-issued context for one activated extension generation (EXT-18). */
+export interface ExtensionContextV1 {
+    /** The extension identity, as the host resolved it. */
+    readonly extensionId: string;
+    /** The installed package version. */
+    readonly extensionVersion: string;
+    /**
+     * Catalog generation this activation belongs to.
+     *
+     * An extension may branch on it, but the HOST decides publication; an extension
+     * cannot publish by incrementing anything it holds.
+     */
+    readonly activationGeneration: number;
+    /** Extension-private storage. */
+    readonly storage: ExtensionStorageV1;
+    /** Bounded diagnostics. */
+    readonly logger: ExtensionLoggerV1;
+    /** Aborted when the host begins disposing this generation. */
+    readonly signal: AbortSignal;
+    /** Host-provided preparation state, when the host has prepared assets. */
+    readonly configuration: Readonly<JsonObject>;
+}
+/** What an inspection found (EXT-18). Read-only; never downloads or infers. */
+export interface ProviderInspectionV1 {
+    /**
+     * Current deployment readiness/residency using the RES-04 state vocabulary.
+     * Prepared-but-cold deployments report `prepared-cold`, not `ready`: readiness
+     * determines whether a call is possible, while residency determines whether a
+     * call must load before running.
+     */
+    readonly readiness: ModelReadiness;
+    /** Features this build actually provides, as opposed to what it declares. */
+    readonly features: readonly string[];
+    /** Prerequisites that are absent, each with a reason. */
+    readonly missing: readonly {
+        readonly name: string;
+        readonly reason: string;
+    }[];
+    /** The runtime the provider would use, e.g. a library version. */
+    readonly runtimeVersion?: string;
+    /** Why the deployment is in this state. */
+    readonly reason?: string;
+}
+/** A verified local asset handle (EXT-18). */
+export interface PreparedAssetMapV1 {
+    /**
+     * Resolve an asset.
+     * @param assetId - the manifest asset id.
+     * @returns the local path and the digest the host verified, or undefined.
+     */
+    get(assetId: string): {
+        readonly path: string;
+        readonly digest: string;
+    } | undefined;
+    /** The asset ids the host verified for this deployment. */
+    readonly assetIds: readonly string[];
+}
+/** Call-scoped, host-granted access (EXT-18). */
+export interface InvocationContextV1 {
+    /** Opaque invocation identity, host-issued and not forgeable by a caller. */
+    readonly invocationId: string;
+    /** Required abort signal. Implementations must observe it. */
+    readonly signal: AbortSignal;
+    /** Effective limits in force for this call. */
+    readonly limits: {
+        readonly maxInputBytes: number;
+        readonly maxAudioSeconds: number;
+        readonly maxResultBytes: number;
+    };
+    /**
+     * Resolve a caller-supplied path against the caller's grants.
+     * @param candidate - the path the caller supplied.
+     * @returns the canonical authorized path.
+     */
+    resolvePath(candidate: string): string;
+    /**
+     * Perform an approved network operation.
+     * @param destination - the destination origin, which must be approved.
+     * @param request - the request body.
+     */
+    fetch?(destination: string, request: JsonObject): Promise<JsonObject>;
+}
+/** One model deployment's provider (EXT-17). */
+export interface ModelProviderV1 {
+    /**
+     * Report readiness and features from approved local state only.
+     *
+     * MUST NOT download, infer, or authenticate to a remote endpoint.
+     * @param signal - cancellation.
+     */
+    inspect(signal: AbortSignal): Promise<ProviderInspectionV1>;
+    /**
+     * Load the prepared assets.
+     *
+     * The host calls this once per selected exact deployment, before any invoke.
+     * @param request - the verified assets and cancellation.
+     */
+    load(request: {
+        readonly assets: Readonly<PreparedAssetMapV1>;
+        readonly signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Run one invocation.
+     *
+     * Returns the domain payload with the reserved root `meta` OMITTED: the host
+     * authors that field, and an extension supplying one is rejected.
+     * @param request - what to run.
+     * @returns the domain payload.
+     */
+    invoke(request: {
+        readonly implementationId: string;
+        readonly input: Readonly<JsonObject>;
+        readonly context: InvocationContextV1;
+    }): Promise<JsonObject>;
+    /**
+     * Release loaded resources, keeping the provider usable.
+     * @param signal - cancellation.
+     */
+    unload(signal: AbortSignal): Promise<void>;
+    /** Release everything. Idempotent, and settles only after owned resources stop. */
+    dispose(): Promise<void>;
+}
+/** An activated extension (EXT-17). */
+export interface ExtensionInstanceV1 {
+    /**
+     * Create a provider for one model deployment.
+     *
+     * Creates a handle; it does not download or load. EXT-19 requires `create()` and
+     * this call to stay lightweight.
+     * @param request - which deployment, and its configuration.
+     */
+    createProvider(request: {
+        readonly modelId: string;
+        readonly configuration: Readonly<JsonObject>;
+    }): Promise<ModelProviderV1>;
+    /**
+     * Release this instance.
+     * @param reason - why it is being disposed.
+     */
+    dispose(reason: DisposeReason): Promise<void>;
+}
+/** What a module extension's `./tool-mode` entry default-exports (EXT-17). */
+export interface ToolModeExtensionV1 {
+    /** The runtime API major. Only 1 exists. */
+    readonly apiVersion: 1;
+    /**
+     * Activate.
+     *
+     * MUST be lightweight: no automatic downloads, model loads, inference,
+     * listening sockets, global registration or unbounded background loops.
+     * @param context - the host-issued context.
+     */
+    create(context: ExtensionContextV1): Promise<ExtensionInstanceV1>;
+}
+/** The only apiVersion this SDK implements. */
+export declare const EXTENSION_API_VERSION = 1;
+/**
+ * Declare an extension, with its shape checked at the declaration site.
+ *
+ * Authors use this rather than exporting an object literal: it makes a typo in
+ * `apiVersion` a compile error instead of a load-time rejection, which is the
+ * difference between finding the mistake in an editor and in an operator's log.
+ * @param extension - the extension to declare.
+ * @returns the same extension, typed.
+ */
+export declare function defineExtension(extension: ToolModeExtensionV1): ToolModeExtensionV1;
+/**
+ * The reserved root field the host authors, which an extension must not supply.
+ *
+ * EXT-17 reserves it so provenance cannot be forged: an extension that returned
+ * its own `meta` would be asserting who ran it and under what receipt.
+ */
+export declare const RESERVED_META_FIELD = "meta";
+/**
+ * Reject an extension result that tries to supply the reserved `meta` field.
+ *
+ * @param payload - the payload an extension returned.
+ * @param implementationId - for the error message.
+ * @throws Error when the payload carries `meta`.
+ */
+export declare function assertNoReservedMeta(payload: JsonObject, implementationId: string): void;
+//# sourceMappingURL=runtime.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/node_modules/@try-works/tool-mode-extension-sdk/lib/runtime.js

@@ -0,0 +1,58 @@
+/**
+ * The public extension runtime API (EXT-17, EXT-18, EXT-19).
+ *
+ * These are the interfaces an extension author implements and a host calls. The
+ * SDK owns them because an author must be able to build and test against them
+ * WITHOUT DSH or the Tool Mode host present (EXT-02): an extension that imported
+ * host internals would be unbuildable for anyone who has not installed the host,
+ * and would break on every host refactor.
+ *
+ * The context objects are deliberately narrow. `ExtensionContextV1` carries no
+ * DSH `ctx`, no registry mutation, no global credentials and no unfiltered
+ * environment; `InvocationContextV1` carries no caller-supplied authority and no
+ * arbitrary tool dispatch. An extension that needs a file or a secret asks the
+ * host through a broker whose grants are the operator's, not the extension's.
+ *
+ * @module @try-works/tool-mode-extension-sdk/runtime
+ */
+/** The only apiVersion this SDK implements. */
+export const EXTENSION_API_VERSION = 1;
+/**
+ * Declare an extension, with its shape checked at the declaration site.
+ *
+ * Authors use this rather than exporting an object literal: it makes a typo in
+ * `apiVersion` a compile error instead of a load-time rejection, which is the
+ * difference between finding the mistake in an editor and in an operator's log.
+ * @param extension - the extension to declare.
+ * @returns the same extension, typed.
+ */
+export function defineExtension(extension) {
+    if (extension.apiVersion !== EXTENSION_API_VERSION) {
+        throw new Error(`extension apiVersion ${String(extension.apiVersion)} is not supported; this SDK implements ${EXTENSION_API_VERSION}`);
+    }
+    if (typeof extension.create !== 'function') {
+        throw new Error('extension must implement create(context)');
+    }
+    return extension;
+}
+/**
+ * The reserved root field the host authors, which an extension must not supply.
+ *
+ * EXT-17 reserves it so provenance cannot be forged: an extension that returned
+ * its own `meta` would be asserting who ran it and under what receipt.
+ */
+export const RESERVED_META_FIELD = 'meta';
+/**
+ * Reject an extension result that tries to supply the reserved `meta` field.
+ *
+ * @param payload - the payload an extension returned.
+ * @param implementationId - for the error message.
+ * @throws Error when the payload carries `meta`.
+ */
+export function assertNoReservedMeta(payload, implementationId) {
+    if (RESERVED_META_FIELD in payload) {
+        throw new Error(`implementation ${implementationId} returned a reserved root "${RESERVED_META_FIELD}" field; `
+            + 'the host authors that metadata and will not accept an extension-supplied one');
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/state.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Orthogonal extension state (EXT-25).
+ *
+ * The governing rule is that ONE boolean cannot describe six independent facts.
+ * A package can be installed but never activated; activated but its model not yet
+ * prepared; prepared but its tool disabled for this profile; enabled but not
+ * exported to an external client. Collapsing those into `enabled` is how a UI ends
+ * up claiming a tool works when a caller cannot reach it.
+ *
+ * This module models each dimension separately and derives the operator-facing
+ * summary from them, so the summary can never disagree with the parts.
+ *
+ * @module @try-works/tool-mode-extension-sdk/state
+ */
+/** Host-owned package inventory state (EXT-25, dimension 1). */
+export type InstallationState = 'absent' | 'staged' | 'installed' | 'uninstalling' | 'cleanup-pending';
+/** What the operator asked for, per named profile (EXT-25, dimension 2). */
+export type DesiredActivation = 'active' | 'inactive';
+/** What the host observes, per named profile (EXT-25, dimension 3). */
+export type ObservedActivation = 'inactive' | 'activating' | 'active' | 'deactivating' | 'failed' | 'quarantined';
+/**
+ * Per-deployment readiness (EXT-25 dimension 4; the RES-04 state set).
+ *
+ * The eight states answer TWO questions, and conflating them is the mistake RES-04
+ * names: readiness determines whether a call is POSSIBLE, while residency determines
+ * how it is ADMITTED. A prepared-but-cold deployment is callable — it simply loads
+ * first — and reporting it as uncallable would withdraw a working tool and make the
+ * tool surface flicker on every warm/cold transition.
+ */
+export type ModelReadiness = 'unavailable' | 'needs-preparation' | 'preparing' | 'prepared-cold' | 'loading' | 'ready' | 'busy' | 'failed';
+/** Per-profile tool selection (EXT-25, dimension 5). */
+export interface ToolSelection {
+    readonly toolName: string;
+    /** Whether the tool is enabled in this profile. */
+    readonly enabled: boolean;
+    /** The implementation selected to serve it, when the host chose one. */
+    readonly selectedImplementation?: string;
+}
+/** Separate server/client grants and licence decisions (EXT-25, dimension 6). */
+export type ExportAuthorization = 'not-exported' | 'granted' | 'denied' | 'revoked';
+/** The complete orthogonal state of one extension in one profile. */
+export interface ExtensionState {
+    /** Extension identity. */
+    readonly extensionId: string;
+    /** Host-owned package inventory state; not profile-scoped. */
+    readonly installation: InstallationState;
+    /** What the operator asked for in this profile. */
+    readonly desiredActivation: DesiredActivation;
+    /** What the host observes in this profile. */
+    readonly observedActivation: ObservedActivation;
+    /** Model readiness keyed by exact deployment identity, not by model name. */
+    readonly readiness: Readonly<Record<string, ModelReadiness>>;
+    /** Tool selection in this profile. */
+    readonly tools: readonly ToolSelection[];
+    /** Export authorization, which is independent of local enablement. */
+    readonly export: ExportAuthorization;
+    /**
+     * The process that published this extension's surface, when it is active.
+     *
+     * Publication handles are IN-MEMORY, so a fresh process cannot see whether the
+     * handles it lacks died with a previous process or belong to a live one. Recording
+     * the owner makes that distinction durable: a restarted process may restore an
+     * `active` extension whose owner is gone, and must refuse one whose owner is alive.
+     */
+    readonly ownerPid?: number;
+}
+/** The operator-facing summary, derived rather than stored. */
+export type ExtensionSummary = 
+/** Available and callable. */
+'ready'
+/** Installed and activated, but a model is not prepared yet. */
+ | 'preparing'
+/** Installed and activated, but every tool is disabled here. */
+ | 'no-tools-enabled'
+/** Installed, deliberately not activated. */
+ | 'inactive'
+/** Activation failed or the host quarantined it. */
+ | 'faulted'
+/** Uninstall started; deletion is pending. */
+ | 'cleanup-pending'
+/** Not installed. */
+ | 'absent';
+/**
+ * Derive the operator-facing summary from the orthogonal state.
+ *
+ * Ordering is the whole point: a faulted activation outranks a readiness problem,
+ * because reporting "preparing" for a package whose activation failed would tell
+ * an operator to wait for something that will never finish.
+ * @param state - the orthogonal state.
+ * @returns the summary an operator surface should show.
+ */
+export declare function summarize(state: ExtensionState): ExtensionSummary;
+/**
+ * Whether a caller may invoke a tool right now, using ONLY persisted state.
+ *
+ * Export authorization is deliberately NOT part of this check: a local caller
+ * being able to call a tool says nothing about whether an external client may, and
+ * conflating the two is exactly what EXT-25 separates.
+ *
+ * SCOPE — read this before using it as an admission decision. This helper sees the
+ * state FILE, which records operator intent and readiness; it cannot see which
+ * contributions were actually PUBLISHED, because that is process-local. It therefore
+ * answers "is this tool enabled and is every declared deployment callable", which is
+ * NOT the same question as "was this tool published and can it be dispatched".
+ *
+ * `ExtensionLifecycle.admits()` is the admission decision: it additionally requires the
+ * tool to be in the committed published surface, and it evaluates readiness per BINDING
+ * rather than over every deployment. This function remains the pure-state predicate the
+ * state tests exercise, and a host that used it alone would admit tools that publication
+ * withheld. Prefer `ExtensionLifecycle.admits()` wherever a lifecycle is available.
+ * @param state - the orthogonal state.
+ * @param toolName - the tool being invoked.
+ * @returns whether the persisted state alone admits the invocation.
+ */
+export declare function admitsInvocation(state: ExtensionState, toolName: string): boolean;
+/** Build the state of a newly installed but not yet activated extension. */
+export declare function installedInactive(extensionId: string): ExtensionState;
+//# sourceMappingURL=state.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,gEAAgE;AAChE,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,cAAc,GACd,iBAAiB,CAAA;AAErB,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,CAAA;AAErD,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,cAAc,GACd,QAAQ,GACR,aAAa,CAAA;AAEjB;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,mBAAmB,GACnB,WAAW,GACX,eAAe,GACf,SAAS,GACT,OAAO,GACP,MAAM,GACN,QAAQ,CAAA;AAEZ,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAA;CACzC;AAED,iFAAiF;AACjF,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAA;AAEnF,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,0BAA0B;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAA;IACxC,mDAAmD;IACnD,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAA;IAC7C,8CAA8C;IAC9C,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAA;IAC5D,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAA;IACxC,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,+DAA+D;AAC/D,MAAM,MAAM,gBAAgB;AAC1B,8BAA8B;AAC5B,OAAO;AACT,gEAAgE;GAC9D,WAAW;AACb,gEAAgE;GAC9D,kBAAkB;AACpB,6CAA6C;GAC3C,UAAU;AACZ,oDAAoD;GAClD,SAAS;AACX,8CAA8C;GAC5C,iBAAiB;AACnB,qBAAqB;GACnB,QAAQ,CAAA;AAEZ;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAwBjE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAWjF;AAcD,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAUrE"}

package/node_modules/@try-works/tool-mode-extension-sdk/lib/state.js

@@ -0,0 +1,113 @@
+/**
+ * Orthogonal extension state (EXT-25).
+ *
+ * The governing rule is that ONE boolean cannot describe six independent facts.
+ * A package can be installed but never activated; activated but its model not yet
+ * prepared; prepared but its tool disabled for this profile; enabled but not
+ * exported to an external client. Collapsing those into `enabled` is how a UI ends
+ * up claiming a tool works when a caller cannot reach it.
+ *
+ * This module models each dimension separately and derives the operator-facing
+ * summary from them, so the summary can never disagree with the parts.
+ *
+ * @module @try-works/tool-mode-extension-sdk/state
+ */
+/**
+ * Derive the operator-facing summary from the orthogonal state.
+ *
+ * Ordering is the whole point: a faulted activation outranks a readiness problem,
+ * because reporting "preparing" for a package whose activation failed would tell
+ * an operator to wait for something that will never finish.
+ * @param state - the orthogonal state.
+ * @returns the summary an operator surface should show.
+ */
+export function summarize(state) {
+    if (state.installation === 'absent')
+        return 'absent';
+    if (state.installation === 'cleanup-pending' || state.installation === 'uninstalling') {
+        return 'cleanup-pending';
+    }
+    if (state.observedActivation === 'failed' || state.observedActivation === 'quarantined') {
+        return 'faulted';
+    }
+    // Desired-inactive is reported as inactive even mid-transition, because the
+    // operator's intent is what the surface is describing.
+    if (state.desiredActivation === 'inactive')
+        return 'inactive';
+    if (state.observedActivation !== 'active')
+        return 'inactive';
+    const readiness = Object.values(state.readiness);
+    if (readiness.some(value => value === 'failed' || value === 'unavailable'))
+        return 'faulted';
+    // A COLD deployment is not "preparing": it is usable and will load on first use, so
+    // reporting it as preparing would tell an operator to wait for something that
+    // already works.
+    if (readiness.some(value => value === 'needs-preparation' || value === 'preparing' || value === 'loading')) {
+        return 'preparing';
+    }
+    if (!state.tools.some(tool => tool.enabled))
+        return 'no-tools-enabled';
+    return 'ready';
+}
+/**
+ * Whether a caller may invoke a tool right now, using ONLY persisted state.
+ *
+ * Export authorization is deliberately NOT part of this check: a local caller
+ * being able to call a tool says nothing about whether an external client may, and
+ * conflating the two is exactly what EXT-25 separates.
+ *
+ * SCOPE — read this before using it as an admission decision. This helper sees the
+ * state FILE, which records operator intent and readiness; it cannot see which
+ * contributions were actually PUBLISHED, because that is process-local. It therefore
+ * answers "is this tool enabled and is every declared deployment callable", which is
+ * NOT the same question as "was this tool published and can it be dispatched".
+ *
+ * `ExtensionLifecycle.admits()` is the admission decision: it additionally requires the
+ * tool to be in the committed published surface, and it evaluates readiness per BINDING
+ * rather than over every deployment. This function remains the pure-state predicate the
+ * state tests exercise, and a host that used it alone would admit tools that publication
+ * withheld. Prefer `ExtensionLifecycle.admits()` wherever a lifecycle is available.
+ * @param state - the orthogonal state.
+ * @param toolName - the tool being invoked.
+ * @returns whether the persisted state alone admits the invocation.
+ */
+export function admitsInvocation(state, toolName) {
+    if (state.installation !== 'installed')
+        return false;
+    if (state.desiredActivation !== 'active')
+        return false;
+    if (state.observedActivation !== 'active')
+        return false;
+    const tool = state.tools.find(candidate => candidate.toolName === toolName);
+    if (tool === undefined || !tool.enabled)
+        return false;
+    // PREPARATION determines callability; RESIDENCY does not. An earlier version
+    // required `ready` here, which made a prepared-but-cold deployment uncallable and
+    // so withdrew a tool that works. `prepared-cold`, `loading` and `busy` are all
+    // callable; only a deployment that is unavailable, unprepared or failed is not.
+    return Object.values(state.readiness).every(value => CALLABLE_READINESS.has(value));
+}
+/**
+ * The readiness states in which a call is possible (RES-04).
+ *
+ * A cold but prepared deployment is callable: the call simply loads first.
+ */
+const CALLABLE_READINESS = new Set([
+    'prepared-cold',
+    'loading',
+    'ready',
+    'busy',
+]);
+/** Build the state of a newly installed but not yet activated extension. */
+export function installedInactive(extensionId) {
+    return {
+        extensionId,
+        installation: 'installed',
+        desiredActivation: 'inactive',
+        observedActivation: 'inactive',
+        readiness: {},
+        tools: [],
+        export: 'not-exported',
+    };
+}
+//# sourceMappingURL=state.js.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/worker/worker-child.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-child.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/worker/worker-child.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-child.d.ts","sourceRoot":"","sources":["../../src/worker/worker-child.ts"],"names":[],"mappings":""}