@jini-ai/agentic 0.4.0 → 0.4.1

package/dist/a2ui/common-types.d.ts

@@ -1,401 +0,0 @@
-/**
- * @module common-types
- *
- * A2UI ("Agent-to-UI") v1.0 common wire types — Zod schemas mirroring
- * `specification/v1_0/json/common_types.json` from https://github.com/a2ui-project/a2ui
- * (fetched and read directly from that repo's `main` branch this session; every field name below
- * was copied from the real JSON Schema `$defs`, not guessed). A2UI is a real, versioned,
- * actively-maintained spec (v1.0 is a release candidate at the time this was written) for agents
- * to stream a declarative, catalog-whitelisted component tree + JSON-Pointer-bound data model to a
- * renderer. See `../source-map.md` for provenance, what was verified against the primary source,
- * and — importantly — why this was hand-rolled from the JSON Schemas rather than built on the
- * official `@a2ui/web_core` npm package (materially version-drifted: see that doc).
- *
- * Scope note: this module is the **wire shape** only (what a message/type looks like on the
- * wire). Catalog membership (which component/function names are actually legal for a given
- * surface) is a separate, runtime concern — see `catalog.ts` and `interpreter.ts`. A component
- * object's own per-type property shape (e.g. what `Text` requires beyond `id`/`component`) is
- * also not encoded here — see `catalog.ts`'s `createLabCatalog()`, which carries all 18 of the real
- * "basic" catalog's components with their closed, per-type property schemas.
- */
-import { z } from 'zod';
-/** `common_types.json#/$defs/ComponentId` — "The unique identifier for a component, used for both definitions and references within the same surface." */
-export declare const ComponentIdSchema: z.ZodString;
-export type ComponentId = z.infer<typeof ComponentIdSchema>;
-/** `common_types.json#/$defs/CallId` — "The unique identifier for an agent initiated function call." */
-export declare const CallIdSchema: z.ZodString;
-export type CallId = z.infer<typeof CallIdSchema>;
-/** `common_types.json#/$defs/DataBinding` — a JSON Pointer (RFC 6901) reference into the data model. */
-export declare const DataBindingSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
-export type DataBinding = z.infer<typeof DataBindingSchema>;
-/**
- * `common_types.json#/$defs/FunctionCall` — "Invokes a named function on the renderer."
- * The real schema additionally constrains `call`/`args` via a `oneOf` against
- * `catalog.json#/$defs/anyFunction` (i.e. the active catalog's own function definitions) or
- * `IndexSystemFunction`. That constraint is catalog-dependent and cannot be expressed in a static
- * wire schema shared across every catalog — it is enforced at runtime instead, by
- * `catalog.ts`/`resolve.ts` (function-name whitelist + `callableFrom` execution-boundary check).
- * This schema only validates the wire shape: `call` is a non-empty string, `args` (if present) is
- * a plain object.
- */
-export declare const FunctionCallSchema: z.ZodType<FunctionCall>;
-export interface FunctionCall {
-    call: string;
-    args?: Record<string, ArgValue> | undefined;
-}
-export type ArgValue = string | number | boolean | unknown[] | DataBinding | FunctionCall | Record<string, unknown>;
-/** `common_types.json#/$defs/DynamicValue` — "A value that can be a literal, a path, or a function call returning any type." */
-export declare const DynamicValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodObject<{
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-export type DynamicValue = z.infer<typeof DynamicValueSchema>;
-/** `common_types.json#/$defs/DynamicString` — literal, JSON-Pointer binding, or `FunctionCall` returning a string. */
-export declare const DynamicStringSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-export type DynamicString = z.infer<typeof DynamicStringSchema>;
-/** `common_types.json#/$defs/DynamicNumber`. */
-export declare const DynamicNumberSchema: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-export type DynamicNumber = z.infer<typeof DynamicNumberSchema>;
-/** `common_types.json#/$defs/DynamicBoolean`. */
-export declare const DynamicBooleanSchema: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-export type DynamicBoolean = z.infer<typeof DynamicBooleanSchema>;
-/** `common_types.json#/$defs/DynamicStringList`. */
-export declare const DynamicStringListSchema: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-export type DynamicStringList = z.infer<typeof DynamicStringListSchema>;
-/**
- * `common_types.json#/$defs/IndexSystemFunction` — "Returns the 0-based index of the current item
- * when rendering a dynamic list from a template. This function MUST ONLY be available when
- * evaluating template items within a list context." `call` is the literal `@index`; catalogs
- * "MUST NOT define functions prefixed with `@`" per the catalog spec's system-namespace rule, so
- * this is the one function name every catalog implicitly carries.
- */
-export declare const IndexSystemFunctionSchema: z.ZodObject<{
-    call: z.ZodLiteral<"@index">;
-    args: z.ZodOptional<z.ZodObject<{
-        offset: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodObject<{
-            path: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            path: string;
-        }, {
-            path: string;
-        }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>;
-    }, "strict", z.ZodTypeAny, {
-        offset?: number | {
-            path: string;
-        } | FunctionCall | undefined;
-    }, {
-        offset?: number | {
-            path: string;
-        } | FunctionCall | undefined;
-    }>>;
-}, "strict", z.ZodTypeAny, {
-    call: "@index";
-    args?: {
-        offset?: number | {
-            path: string;
-        } | FunctionCall | undefined;
-    } | undefined;
-}, {
-    call: "@index";
-    args?: {
-        offset?: number | {
-            path: string;
-        } | FunctionCall | undefined;
-    } | undefined;
-}>;
-export type IndexSystemFunction = z.infer<typeof IndexSystemFunctionSchema>;
-/** `common_types.json#/$defs/AccessibilityAttributes`. */
-export declare const AccessibilityAttributesSchema: z.ZodObject<{
-    label: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        path: string;
-    }, {
-        path: string;
-    }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>;
-    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        path: string;
-    }, {
-        path: string;
-    }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>;
-}, "strict", z.ZodTypeAny, {
-    label?: string | {
-        path: string;
-    } | FunctionCall | undefined;
-    description?: string | {
-        path: string;
-    } | FunctionCall | undefined;
-}, {
-    label?: string | {
-        path: string;
-    } | FunctionCall | undefined;
-    description?: string | {
-        path: string;
-    } | FunctionCall | undefined;
-}>;
-export type AccessibilityAttributes = z.infer<typeof AccessibilityAttributesSchema>;
-/** `common_types.json#/$defs/ComponentCommon` — every component carries at least `id`. */
-export declare const ComponentCommonSchema: z.ZodObject<{
-    id: z.ZodString;
-    accessibility: z.ZodOptional<z.ZodObject<{
-        label: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            path: string;
-        }, {
-            path: string;
-        }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>;
-        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            path: string;
-        }, {
-            path: string;
-        }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>;
-    }, "strict", z.ZodTypeAny, {
-        label?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-        description?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-    }, {
-        label?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-        description?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    accessibility?: {
-        label?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-        description?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-    } | undefined;
-}, {
-    id: string;
-    accessibility?: {
-        label?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-        description?: string | {
-            path: string;
-        } | FunctionCall | undefined;
-    } | undefined;
-}>;
-export type ComponentCommon = z.infer<typeof ComponentCommonSchema>;
-/** `common_types.json#/$defs/Child` — "A reference to a single child component ID." */
-export declare const ChildSchema: z.ZodString;
-export type Child = ComponentId;
-/**
- * `common_types.json#/$defs/ChildList` — either a static array of `ComponentId`s, or a template
- * object (`{componentId, path}`) that generates one child per item in a data-model list.
- */
-export declare const ChildListSchema: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
-    componentId: z.ZodString;
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-    componentId: string;
-}, {
-    path: string;
-    componentId: string;
-}>]>;
-export type ChildList = z.infer<typeof ChildListSchema>;
-export type ChildListTemplate = Extract<ChildList, {
-    componentId: string;
-}>;
-/** `common_types.json#/$defs/CheckRule` — "A single validation rule applied to an input component." */
-export declare const CheckRuleSchema: z.ZodObject<{
-    condition: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-        path: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        path: string;
-    }, {
-        path: string;
-    }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-    message: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    message: string;
-    condition: boolean | {
-        path: string;
-    } | FunctionCall;
-}, {
-    message: string;
-    condition: boolean | {
-        path: string;
-    } | FunctionCall;
-}>;
-export type CheckRule = z.infer<typeof CheckRuleSchema>;
-/** `common_types.json#/$defs/Checkable`. */
-export declare const CheckableSchema: z.ZodObject<{
-    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        condition: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-            path: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            path: string;
-        }, {
-            path: string;
-        }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>;
-        message: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        message: string;
-        condition: boolean | {
-            path: string;
-        } | FunctionCall;
-    }, {
-        message: string;
-        condition: boolean | {
-            path: string;
-        } | FunctionCall;
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    checks?: {
-        message: string;
-        condition: boolean | {
-            path: string;
-        } | FunctionCall;
-    }[] | undefined;
-}, {
-    checks?: {
-        message: string;
-        condition: boolean | {
-            path: string;
-        } | FunctionCall;
-    }[] | undefined;
-}>;
-export type Checkable = z.infer<typeof CheckableSchema>;
-/**
- * `common_types.json#/$defs/Action` — "Defines an interaction handler that can either trigger an
- * agent-side event or execute a local renderer-side function." The two variants are mutually
- * exclusive on the wire (each is `.strict()` with only its own key).
- */
-export declare const AgentActionEventSchema: z.ZodObject<{
-    name: z.ZodString;
-    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodObject<{
-        path: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        path: string;
-    }, {
-        path: string;
-    }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>>;
-    wantResponse: z.ZodOptional<z.ZodBoolean>;
-    responsePath: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    context?: Record<string, string | number | boolean | unknown[] | {
-        path: string;
-    } | FunctionCall> | undefined;
-    wantResponse?: boolean | undefined;
-    responsePath?: string | undefined;
-}, {
-    name: string;
-    context?: Record<string, string | number | boolean | unknown[] | {
-        path: string;
-    } | FunctionCall> | undefined;
-    wantResponse?: boolean | undefined;
-    responsePath?: string | undefined;
-}>;
-export type AgentActionEvent = z.infer<typeof AgentActionEventSchema>;
-export declare const ActionSchema: z.ZodUnion<[z.ZodObject<{
-    event: z.ZodObject<{
-        name: z.ZodString;
-        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodObject<{
-            path: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            path: string;
-        }, {
-            path: string;
-        }>, z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>]>>>;
-        wantResponse: z.ZodOptional<z.ZodBoolean>;
-        responsePath: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        name: string;
-        context?: Record<string, string | number | boolean | unknown[] | {
-            path: string;
-        } | FunctionCall> | undefined;
-        wantResponse?: boolean | undefined;
-        responsePath?: string | undefined;
-    }, {
-        name: string;
-        context?: Record<string, string | number | boolean | unknown[] | {
-            path: string;
-        } | FunctionCall> | undefined;
-        wantResponse?: boolean | undefined;
-        responsePath?: string | undefined;
-    }>;
-}, "strict", z.ZodTypeAny, {
-    event: {
-        name: string;
-        context?: Record<string, string | number | boolean | unknown[] | {
-            path: string;
-        } | FunctionCall> | undefined;
-        wantResponse?: boolean | undefined;
-        responsePath?: string | undefined;
-    };
-}, {
-    event: {
-        name: string;
-        context?: Record<string, string | number | boolean | unknown[] | {
-            path: string;
-        } | FunctionCall> | undefined;
-        wantResponse?: boolean | undefined;
-        responsePath?: string | undefined;
-    };
-}>, z.ZodObject<{
-    functionCall: z.ZodType<FunctionCall, z.ZodTypeDef, FunctionCall>;
-}, "strict", z.ZodTypeAny, {
-    functionCall: FunctionCall;
-}, {
-    functionCall: FunctionCall;
-}>]>;
-export type Action = z.infer<typeof ActionSchema>;
-export type AgentEventAction = Extract<Action, {
-    event: AgentActionEvent;
-}>;
-export type LocalFunctionAction = Extract<Action, {
-    functionCall: FunctionCall;
-}>;
-export declare function isAgentEventAction(action: Action): action is AgentEventAction;
-export declare function isLocalFunctionAction(action: Action): action is LocalFunctionAction;
-//# sourceMappingURL=common-types.d.ts.map

package/dist/a2ui/common-types.js

@@ -1,130 +0,0 @@
-/**
- * @module common-types
- *
- * A2UI ("Agent-to-UI") v1.0 common wire types — Zod schemas mirroring
- * `specification/v1_0/json/common_types.json` from https://github.com/a2ui-project/a2ui
- * (fetched and read directly from that repo's `main` branch this session; every field name below
- * was copied from the real JSON Schema `$defs`, not guessed). A2UI is a real, versioned,
- * actively-maintained spec (v1.0 is a release candidate at the time this was written) for agents
- * to stream a declarative, catalog-whitelisted component tree + JSON-Pointer-bound data model to a
- * renderer. See `../source-map.md` for provenance, what was verified against the primary source,
- * and — importantly — why this was hand-rolled from the JSON Schemas rather than built on the
- * official `@a2ui/web_core` npm package (materially version-drifted: see that doc).
- *
- * Scope note: this module is the **wire shape** only (what a message/type looks like on the
- * wire). Catalog membership (which component/function names are actually legal for a given
- * surface) is a separate, runtime concern — see `catalog.ts` and `interpreter.ts`. A component
- * object's own per-type property shape (e.g. what `Text` requires beyond `id`/`component`) is
- * also not encoded here — see `catalog.ts`'s `createLabCatalog()`, which carries all 18 of the real
- * "basic" catalog's components with their closed, per-type property schemas.
- */
-import { z } from 'zod';
-/** `common_types.json#/$defs/ComponentId` — "The unique identifier for a component, used for both definitions and references within the same surface." */
-export const ComponentIdSchema = z.string();
-/** `common_types.json#/$defs/CallId` — "The unique identifier for an agent initiated function call." */
-export const CallIdSchema = z.string();
-/** `common_types.json#/$defs/DataBinding` — a JSON Pointer (RFC 6901) reference into the data model. */
-export const DataBindingSchema = z.object({ path: z.string() }).strict();
-/**
- * `common_types.json#/$defs/FunctionCall` — "Invokes a named function on the renderer."
- * The real schema additionally constrains `call`/`args` via a `oneOf` against
- * `catalog.json#/$defs/anyFunction` (i.e. the active catalog's own function definitions) or
- * `IndexSystemFunction`. That constraint is catalog-dependent and cannot be expressed in a static
- * wire schema shared across every catalog — it is enforced at runtime instead, by
- * `catalog.ts`/`resolve.ts` (function-name whitelist + `callableFrom` execution-boundary check).
- * This schema only validates the wire shape: `call` is a non-empty string, `args` (if present) is
- * a plain object.
- */
-export const FunctionCallSchema = z.lazy(() => z
-    .object({
-    call: z.string(),
-    args: z.record(z.string(), ArgValueSchema).optional(),
-})
-    .strict());
-/** `common_types.json#/$defs/DynamicValue`'s `args`-position shape: a `DynamicValue`, or a literal object (catalog-defined config). Recursive because `args` values may themselves be `FunctionCall`s. */
-const ArgValueSchema = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.array(z.unknown()), DataBindingSchema, FunctionCallSchema, z.record(z.string(), z.unknown())]));
-/** `common_types.json#/$defs/DynamicValue` — "A value that can be a literal, a path, or a function call returning any type." */
-export const DynamicValueSchema = z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.array(z.unknown()),
-    DataBindingSchema,
-    FunctionCallSchema,
-]);
-/** `common_types.json#/$defs/DynamicString` — literal, JSON-Pointer binding, or `FunctionCall` returning a string. */
-export const DynamicStringSchema = z.union([z.string(), DataBindingSchema, FunctionCallSchema]);
-/** `common_types.json#/$defs/DynamicNumber`. */
-export const DynamicNumberSchema = z.union([z.number(), DataBindingSchema, FunctionCallSchema]);
-/** `common_types.json#/$defs/DynamicBoolean`. */
-export const DynamicBooleanSchema = z.union([z.boolean(), DataBindingSchema, FunctionCallSchema]);
-/** `common_types.json#/$defs/DynamicStringList`. */
-export const DynamicStringListSchema = z.union([z.array(z.string()), DataBindingSchema, FunctionCallSchema]);
-/**
- * `common_types.json#/$defs/IndexSystemFunction` — "Returns the 0-based index of the current item
- * when rendering a dynamic list from a template. This function MUST ONLY be available when
- * evaluating template items within a list context." `call` is the literal `@index`; catalogs
- * "MUST NOT define functions prefixed with `@`" per the catalog spec's system-namespace rule, so
- * this is the one function name every catalog implicitly carries.
- */
-export const IndexSystemFunctionSchema = z
-    .object({
-    call: z.literal('@index'),
-    args: z.object({ offset: DynamicNumberSchema.optional() }).strict().optional(),
-})
-    .strict();
-/** `common_types.json#/$defs/AccessibilityAttributes`. */
-export const AccessibilityAttributesSchema = z
-    .object({
-    label: DynamicStringSchema.optional(),
-    description: DynamicStringSchema.optional(),
-})
-    .strict();
-/** `common_types.json#/$defs/ComponentCommon` — every component carries at least `id`. */
-export const ComponentCommonSchema = z.object({
-    id: ComponentIdSchema,
-    accessibility: AccessibilityAttributesSchema.optional(),
-});
-/** `common_types.json#/$defs/Child` — "A reference to a single child component ID." */
-export const ChildSchema = ComponentIdSchema;
-/**
- * `common_types.json#/$defs/ChildList` — either a static array of `ComponentId`s, or a template
- * object (`{componentId, path}`) that generates one child per item in a data-model list.
- */
-export const ChildListSchema = z.union([
-    z.array(ComponentIdSchema),
-    z.object({ componentId: ComponentIdSchema, path: z.string() }).strict(),
-]);
-/** `common_types.json#/$defs/CheckRule` — "A single validation rule applied to an input component." */
-export const CheckRuleSchema = z
-    .object({
-    condition: DynamicBooleanSchema,
-    message: z.string(),
-})
-    .strict();
-/** `common_types.json#/$defs/Checkable`. */
-export const CheckableSchema = z.object({ checks: z.array(CheckRuleSchema).optional() });
-/**
- * `common_types.json#/$defs/Action` — "Defines an interaction handler that can either trigger an
- * agent-side event or execute a local renderer-side function." The two variants are mutually
- * exclusive on the wire (each is `.strict()` with only its own key).
- */
-export const AgentActionEventSchema = z
-    .object({
-    name: z.string(),
-    context: z.record(z.string(), DynamicValueSchema).optional(),
-    wantResponse: z.boolean().optional(),
-    responsePath: z.string().optional(),
-})
-    .strict();
-export const ActionSchema = z.union([
-    z.object({ event: AgentActionEventSchema }).strict(),
-    z.object({ functionCall: FunctionCallSchema }).strict(),
-]);
-export function isAgentEventAction(action) {
-    return 'event' in action;
-}
-export function isLocalFunctionAction(action) {
-    return 'functionCall' in action;
-}
-//# sourceMappingURL=common-types.js.map

package/dist/a2ui/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * @module @jini-ai/a2ui
- *
- * A2UI ("Agent-to-UI") v1.0 wire types + a minimal client-side interpreter — see each module's
- * own doc for detail, and `source-map.md` for provenance, verified-against-primary-source notes,
- * and the honest gap list against full v1.0 spec parity.
- */
-export * from './common-types.js';
-export * from './agent-to-renderer.js';
-export * from './renderer-to-agent.js';
-export * from './catalog.js';
-export * from './json-pointer.js';
-export * from './resolve.js';
-export * from './tree.js';
-export * from './interpreter.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/a2ui/index.js

@@ -1,16 +0,0 @@
-/**
- * @module @jini-ai/a2ui
- *
- * A2UI ("Agent-to-UI") v1.0 wire types + a minimal client-side interpreter — see each module's
- * own doc for detail, and `source-map.md` for provenance, verified-against-primary-source notes,
- * and the honest gap list against full v1.0 spec parity.
- */
-export * from './common-types.js';
-export * from './agent-to-renderer.js';
-export * from './renderer-to-agent.js';
-export * from './catalog.js';
-export * from './json-pointer.js';
-export * from './resolve.js';
-export * from './tree.js';
-export * from './interpreter.js';
-//# sourceMappingURL=index.js.map

package/dist/a2ui/interpreter.d.ts

@@ -1,71 +0,0 @@
-import type { ParseFailure } from './agent-to-renderer.js';
-import { WireComponentSchema } from './agent-to-renderer.js';
-import type { RendererToAgentMessage } from './renderer-to-agent.js';
-import { type Catalog } from './catalog.js';
-import { resolveDynamicValue } from './resolve.js';
-import { type DynamicValue, type LocalFunctionAction } from './common-types.js';
-export interface ComponentInstance {
-    readonly id: string;
-    readonly component: string;
-    /** Validated + defaulted per the catalog's own per-type schema. Does not include `id`/`component`. */
-    readonly props: Record<string, unknown>;
-}
-export interface SurfaceSnapshot {
-    readonly surfaceId: string;
-    readonly catalogId: string;
-    readonly components: ReadonlyMap<string, ComponentInstance>;
-    readonly dataModel: unknown;
-}
-export interface ApplyMessageResult {
-    readonly rendererMessages: readonly RendererToAgentMessage[];
-    /** See module doc, decision 4. Not part of the wire protocol — a local-only diagnostic. */
-    readonly unattributedViolation?: string;
-}
-export type BuildActionResult = {
-    readonly ok: true;
-    readonly kind: 'agent';
-    readonly message: RendererToAgentMessage;
-} | {
-    readonly ok: true;
-    readonly kind: 'local';
-    readonly result: unknown;
-} | {
-    readonly ok: false;
-    readonly reason: string;
-};
-/**
- * Turns a `ParseFailure` (from `parseAgentToRendererMessage`) into what `applyAgentMessage`
- * returns for it. See this module's doc, decision 4: an envelope malformed enough to carry no
- * attributable `surfaceId`/`functionCallId` cannot be turned into a spec-shaped `error` message —
- * `renderer_to_agent.json`'s own generic-error schema *requires* one of those two identifiers —
- * so it surfaces out-of-band via `unattributedViolation` (a string, not sent over the wire)
- * instead of forcing a fake identifier into a wire-conformant shape.
- *
- * Exported and pure — it only reads `parsed`/`raw`, so the surfaceId-attribution rule can be
- * tested directly, without a live interpreter instance.
- */
-export declare function buildParseFailureResult(parsed: ParseFailure, raw: unknown): ApplyMessageResult;
-/**
- * Runs a component's local `functionCall` action synchronously against `dataModel` — no network
- * round trip, no pending-action bookkeeping (that only applies to the agent-event branch; see
- * `interpreter`'s `buildAction`/`buildAgentEventAction`).
- *
- * Exported and pure given its inputs, so "a local action resolves against the surface's actual
- * data model, and a resolution failure becomes a typed refusal rather than a thrown error" can be
- * tested without a live interpreter instance.
- */
-export declare function runLocalFunctionAction(dataModel: unknown, catalog: Catalog, action: LocalFunctionAction): BuildActionResult;
-export interface A2uiInterpreter {
-    applyAgentMessage(raw: unknown): ApplyMessageResult;
-    getSurface(surfaceId: string): SurfaceSnapshot | undefined;
-    listSurfaceIds(): string[];
-    /** `undefined` if the surface doesn't exist, or exists but has no component with id `'root'` yet (a legal, "still streaming in" state per the spec's own forward-reference tolerance). */
-    getRoot(surfaceId: string): ComponentInstance | undefined;
-    /** Resolves a component's `action` prop (if any) for dispatch — builds the `action` envelope for an agent-event action, or synchronously runs a local `functionCall` action. Called by a host renderer on a real user interaction (e.g. a Button click). */
-    buildAction(surfaceId: string, componentId: string, now?: () => number): BuildActionResult;
-    resolve(surfaceId: string, value: DynamicValue, itemBasePath?: string, itemIndex?: number): ReturnType<typeof resolveDynamicValue>;
-    subscribe(listener: () => void): () => void;
-}
-export declare function createA2uiInterpreter(catalog: Catalog): A2uiInterpreter;
-export { WireComponentSchema };
-//# sourceMappingURL=interpreter.d.ts.map