@jini-ai/agentic 0.4.3 → 0.4.5

package/dist/capability.js

@@ -1,79 +0,0 @@
-/**
- * @module capability
- *
- * The vocabulary every agent-drivable surface shares: what an outside caller may ask a
- * frontend to do, described as pure data with no transport, DOM, or framework attached.
- *
- * One noun, deliberately: **capability**. The chat pane's first draft used `tool` in its
- * type names and `capability` in its ids, which forked the vocabulary across four files.
- * `tool` stays reserved for the engine's own `ToolRegistry`/`ToolExecutor` nouns; anything
- * an outside caller asks a *frontend* to do is a capability. Transports may of course
- * present capabilities as MCP tools — that is a projection, not a rename.
- */
-/**
- * Looks a capability up by id.
- *
- * @param capabilities - The manifest to search.
- * @param id - Capability id to resolve.
- * @returns The definition, or `undefined` when the id is not in the manifest.
- */
-export function findCapability(capabilities, id) {
-    return capabilities.find((capability) => capability.id === id);
-}
-/**
- * Checks caller input against a capability's declared schema.
- *
- * Manifests advertise `additionalProperties: false` and a `required` list, but nothing was
- * enforcing either — handlers read the fields they knew about and ignored the rest, so a
- * misnamed argument silently became a missing one. This closes that for any surface that calls
- * it. Intentionally a shallow check, not a JSON Schema engine: these schemas are flat by
- * construction, and a real validator is a dependency this package will not take.
- *
- * @param capability - The capability being invoked.
- * @param input - Raw caller-supplied arguments.
- * @returns An error message, or `null` when the input is acceptable.
- */
-export function findCapabilityInputError(capability, input) {
-    const { properties, required, additionalProperties } = capability.inputSchema;
-    for (const name of required ?? []) {
-        if (input[name] === undefined)
-            return `"${name}" is required`;
-    }
-    if (additionalProperties === false) {
-        // `key in properties` walks the whole prototype chain, so a key that happens to be inherited
-        // from Object.prototype (`__proto__`, `constructor`, `toString`, `valueOf`, …) reads as
-        // "known" regardless of whether the schema actually lists it — `'constructor' in {}` is
-        // true even on an empty object. `JSON.parse('{"__proto__":...}')` creates a real own data
-        // property (not the accessor), so this was a live way for such a key to escape the
-        // "unknown argument" refusal entirely. hasOwnProperty ignores the prototype chain, so only
-        // keys the schema actually declares count as known.
-        const unknown = Object.keys(input)
-            .filter((key) => !Object.prototype.hasOwnProperty.call(properties, key));
-        if (unknown.length > 0) {
-            return `unknown ${unknown.length === 1 ? 'argument' : 'arguments'}: ${unknown.sort().join(', ')}`;
-        }
-    }
-    for (const [name, schema] of Object.entries(properties)) {
-        const value = input[name];
-        if (value === undefined)
-            continue;
-        const actual = Array.isArray(value) ? 'array' : typeof value;
-        if (actual !== schema.type)
-            return `"${name}" must be a ${schema.type}, received ${actual}`;
-        if (schema.enum !== undefined && !schema.enum.includes(value)) {
-            return `"${name}" must be one of: ${schema.enum.join(', ')}`;
-        }
-    }
-    return null;
-}
-/**
- * The capabilities a caller may use given what is currently connected.
- *
- * @param capabilities - The full manifest.
- * @param hasSession - Whether a live frontend session is attached.
- * @returns Only the capabilities that can actually be satisfied right now.
- */
-export function availableCapabilities(capabilities, hasSession) {
-    return hasSession ? capabilities : capabilities.filter((c) => c.surface === 'server');
-}
-//# sourceMappingURL=capability.js.map

package/dist/dom/dom-page-driver.d.ts

@@ -1,36 +0,0 @@
-import type { PageDriver } from '../page-driver.js';
-/** One page a host allows navigation to: its human label, and how to actually get there. */
-export interface DomPageDriverPage {
-    /** Shown to a caller by `page.find_elements`/`page.navigate`'s refusal message — see
-     *  `PageSummary.label` for why this exists at all. */
-    readonly label: string;
-    readonly navigate: () => void;
-}
-export interface DomPageDriverOptions {
-    /** The subtree to expose. Never pass `document`. */
-    readonly root: ParentNode & {
-        querySelector: Element['querySelector'];
-    };
-    /** Page ids this driver may navigate to, each with its label and how to get there. */
-    readonly pages: Readonly<Record<string, DomPageDriverPage>>;
-    /**
-     * The id of the page currently shown, reported on every element.
-     *
-     * Omit it in a single-page app that swaps views: the driver then reads `data-agent-page` from
-     * the live DOM on every call, so navigating actually changes what elements report. A value
-     * captured here is fixed for the driver's whole lifetime, which is right only for a surface that
-     * never changes view — and silently wrong for one that does, since the driver outlives any one
-     * view (it is bound to the connection, not the render).
-     */
-    readonly currentPage?: string | undefined;
-}
-/**
- * Builds a driver over `root`.
- *
- * @param options - The subtree, the navigable pages, and the current page id.
- * @returns A driver ready to hand to `executePageCapability`.
- */
-export declare function createDomPageDriver(options: DomPageDriverOptions): PageDriver;
-/** Reads the current page's `data-agent-page`, for hosts that tag the body. */
-export declare function currentAgentPage(root: ParentNode): string | undefined;
-//# sourceMappingURL=dom-page-driver.d.ts.map