@vibesdotdev/tools 0.0.0-stage → 1.0.0-rc.4

package/dist/svelte/tool-widgets/payload.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The one boundary where a first-party tool card reads its call's `input` and
+ * `output`.
+ *
+ * A `ToolCallView` carries whatever the tool or the model produced, so a card
+ * never trusts its shape. Each card declares the fields it renders as a Zod
+ * shape and reads them here:
+ *
+ * - every field is parsed on its own, so one malformed field never hides the
+ *   others (a wrong-typed `path` does not blank the `content`);
+ * - a list is read item by item, so one malformed row never drops the batch;
+ * - a value that throws while being read (a throwing getter, a trapping or
+ *   revoked Proxy) settles as that field's absence. `safeParse` reports a bad
+ *   shape but lets such a throw escape, which would take the whole card down
+ *   mid-render; the throw is reduced to its value-free facts and the field
+ *   renders as missing, exactly as a field the tool never sent.
+ *
+ * Cards then branch on the parsed domain values only.
+ */
+import * as z from 'zod/v4';
+import { type ValueFreeFailure } from '@vibesdotdev/kernel';
+/** A card's declared fields: field name to its schema. */
+export type CardFieldSchemas = Readonly<Record<string, z.ZodType>>;
+/** How one read through a schema settled. */
+export type PayloadRead<Output> = {
+    readonly read: 'parsed';
+    readonly data: Output;
+} | {
+    readonly read: 'invalid';
+} | {
+    readonly read: 'unreadable';
+    readonly failure: ValueFreeFailure;
+};
+/** A payload object read once into a plain copy, so no getter runs twice. */
+declare const PayloadObjectSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/** Parse `value` with `schema`, settling a throw from the read itself as `unreadable`. */
+export declare function readPayload<Schema extends z.ZodType, Input>(schema: Schema, value: Input): PayloadRead<z.output<Schema>>;
+/** The parsed value, or `undefined` for an invalid or unreadable one. */
+export declare function parsedOrUndefined<Output>(settled: PayloadRead<Output>): Output | undefined;
+/** A payload object as read once: its own keys and their values, not yet parsed. */
+type PayloadRecord = z.output<typeof PayloadObjectSchema>;
+/**
+ * A card's view of one payload object. `get` parses the named field on its
+ * own from the copy taken at read time; a non-object payload (null, an array,
+ * a string) has no fields, and an absent, malformed or unreadable field is
+ * `undefined`.
+ */
+export declare class CardPayload<Declared extends CardFieldSchemas> {
+    #private;
+    constructor(declared: Declared, record: PayloadRecord | undefined);
+    /** True when the payload was an object (its fields may still be absent). */
+    isObject(): boolean;
+    get<Key extends keyof Declared & string>(key: Key): z.output<Declared[Key]> | undefined;
+}
+/** Read a payload object (a call's `input` or `output`, or one nested object) for its declared fields. */
+export declare function readCardPayload<Declared extends CardFieldSchemas, Input>(declared: Declared, value: Input): CardPayload<Declared>;
+/**
+ * Read a list of objects item by item: each item is its own payload, so one
+ * malformed row never drops the others (a non-list reads as empty).
+ */
+export declare function readCardPayloadList<Declared extends CardFieldSchemas, Input>(declared: Declared, value: Input): CardPayload<Declared>[];
+/** Read a list of values through one item schema, dropping each item that fails on its own. */
+export declare function readPayloadValues<Schema extends z.ZodType, Input>(schema: Schema, value: Input): z.output<Schema>[];
+export {};
+//# sourceMappingURL=payload.d.ts.map

package/dist/svelte/tool-widgets/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/payload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAyC,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEnG,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAEnE,6CAA6C;AAC7C,MAAM,MAAM,WAAW,CAAC,MAAM,IAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAEvE,6EAA6E;AAC7E,QAAA,MAAM,mBAAmB,wCAAoC,CAAC;AAK9D,0FAA0F;AAC1F,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,OAAO,EAAE,KAAK,EAC1D,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,GACV,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAO/B;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS,CAE1F;AAED,oFAAoF;AACpF,KAAK,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,qBAAa,WAAW,CAAC,QAAQ,SAAS,gBAAgB;;gBAI7C,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,GAAG,SAAS;IAKjE,4EAA4E;IAC5E,QAAQ,IAAI,OAAO;IAInB,GAAG,CAAC,GAAG,SAAS,MAAM,QAAQ,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS;CAKvF;AAED,0GAA0G;AAC1G,wBAAgB,eAAe,CAAC,QAAQ,SAAS,gBAAgB,EAAE,KAAK,EACvE,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,KAAK,GACV,WAAW,CAAC,QAAQ,CAAC,CAEvB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,gBAAgB,EAAE,KAAK,EAC3E,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,KAAK,GACV,WAAW,CAAC,QAAQ,CAAC,EAAE,CAGzB;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAAC,MAAM,SAAS,CAAC,CAAC,OAAO,EAAE,KAAK,EAChE,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,GACV,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAQpB"}

package/dist/svelte/tool-widgets/payload.js

@@ -0,0 +1,86 @@
+/**
+ * The one boundary where a first-party tool card reads its call's `input` and
+ * `output`.
+ *
+ * A `ToolCallView` carries whatever the tool or the model produced, so a card
+ * never trusts its shape. Each card declares the fields it renders as a Zod
+ * shape and reads them here:
+ *
+ * - every field is parsed on its own, so one malformed field never hides the
+ *   others (a wrong-typed `path` does not blank the `content`);
+ * - a list is read item by item, so one malformed row never drops the batch;
+ * - a value that throws while being read (a throwing getter, a trapping or
+ *   revoked Proxy) settles as that field's absence. `safeParse` reports a bad
+ *   shape but lets such a throw escape, which would take the whole card down
+ *   mid-render; the throw is reduced to its value-free facts and the field
+ *   renders as missing, exactly as a field the tool never sent.
+ *
+ * Cards then branch on the parsed domain values only.
+ */
+import * as z from 'zod/v4';
+import { CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+/** A payload object read once into a plain copy, so no getter runs twice. */
+const PayloadObjectSchema = z.record(z.string(), z.unknown());
+/** A payload list read once into a plain copy. */
+const PayloadListSchema = z.array(z.unknown());
+/** Parse `value` with `schema`, settling a throw from the read itself as `unreadable`. */
+export function readPayload(schema, value) {
+    try {
+        const result = schema.safeParse(value);
+        return result.success ? { read: 'parsed', data: result.data } : { read: 'invalid' };
+    }
+    catch (error) {
+        return { read: 'unreadable', failure: valueFreeFailure(CaughtFailureSchema.parse(error)) };
+    }
+}
+/** The parsed value, or `undefined` for an invalid or unreadable one. */
+export function parsedOrUndefined(settled) {
+    return settled.read === 'parsed' ? settled.data : undefined;
+}
+/**
+ * A card's view of one payload object. `get` parses the named field on its
+ * own from the copy taken at read time; a non-object payload (null, an array,
+ * a string) has no fields, and an absent, malformed or unreadable field is
+ * `undefined`.
+ */
+export class CardPayload {
+    #declared;
+    #record;
+    constructor(declared, record) {
+        this.#declared = declared;
+        this.#record = record;
+    }
+    /** True when the payload was an object (its fields may still be absent). */
+    isObject() {
+        return this.#record !== undefined;
+    }
+    get(key) {
+        const record = this.#record;
+        if (record === undefined || !Object.hasOwn(record, key))
+            return undefined;
+        return parsedOrUndefined(readPayload(this.#declared[key], record[key]));
+    }
+}
+/** Read a payload object (a call's `input` or `output`, or one nested object) for its declared fields. */
+export function readCardPayload(declared, value) {
+    return new CardPayload(declared, parsedOrUndefined(readPayload(PayloadObjectSchema, value)));
+}
+/**
+ * Read a list of objects item by item: each item is its own payload, so one
+ * malformed row never drops the others (a non-list reads as empty).
+ */
+export function readCardPayloadList(declared, value) {
+    const items = parsedOrUndefined(readPayload(PayloadListSchema, value)) ?? [];
+    return items.map((item) => readCardPayload(declared, item));
+}
+/** Read a list of values through one item schema, dropping each item that fails on its own. */
+export function readPayloadValues(schema, value) {
+    const items = parsedOrUndefined(readPayload(PayloadListSchema, value)) ?? [];
+    const values = [];
+    for (const item of items) {
+        const settled = readPayload(schema, item);
+        if (settled.read === 'parsed')
+            values.push(settled.data);
+    }
+    return values;
+}

package/dist/svelte/tool-widgets/run-log-thread.d.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod/v4';
+import type { RunnableLogEntry } from '@vibesdotdev/runnable/svelte';
+import type { ToolCallView } from '@vibesdotdev/kit/components/tool-widgets';
+/** Public tool presentation carried by execution reports; no inspection of arbitrary log text. */
+export declare const ExecutionToolViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodString;
+    input: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>;
+    output: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function runLogThread(logs: readonly RunnableLogEntry[]): {
+    entries: RunnableLogEntry[];
+    calls: Map<number, ToolCallView>;
+    focus: Map<number, number>;
+};
+//# sourceMappingURL=run-log-thread.d.ts.map

package/dist/svelte/tool-widgets/run-log-thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-log-thread.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/run-log-thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAG7E,kGAAkG;AAClG,eAAO,MAAM,uBAAuB;;;;;;;;iBAGlC,CAAC;AAIH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,gBAAgB,EAAE;;;;EAiC7D"}

package/dist/svelte/tool-widgets/run-log-thread.js

@@ -0,0 +1,46 @@
+import * as z from 'zod/v4';
+import { ExecutionReportSchema } from '@vibesdotdev/kernel';
+import { RunnableEventLogDataSchema } from '@vibesdotdev/runnable/events';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+/** Public tool presentation carried by execution reports; no inspection of arbitrary log text. */
+export const ExecutionToolViewSchema = z.object({
+    id: z.string(), name: z.string(), status: z.string(), input: JsonValueSchema.optional(),
+    output: JsonValueSchema.optional(), error: z.string().optional(), durationMs: z.number().optional()
+});
+const ActivityPayloadSchema = z.object({ activity: z.object({ tool: ExecutionToolViewSchema }) });
+const DirectPayloadSchema = z.object({ tool: ExecutionToolViewSchema });
+export function runLogThread(logs) {
+    const entries = [];
+    const calls = new Map();
+    const focus = new Map();
+    const positions = new Map();
+    const updates = new Map();
+    for (const [index, log] of logs.entries()) {
+        const envelope = RunnableEventLogDataSchema.safeParse(log.data);
+        const event = envelope.success ? envelope.data.event : null;
+        const direct = DirectPayloadSchema.safeParse(event?.data);
+        const wrapped = ActivityPayloadSchema.safeParse(event?.data);
+        const tool = direct.success ? direct.data.tool : wrapped.success ? wrapped.data.activity.tool : null;
+        if (!tool) {
+            const report = ExecutionReportSchema.safeParse(event);
+            entries.push({ ...log, id: index, message: report.success ? report.data.message ?? log.message : log.message });
+            continue;
+        }
+        const first = positions.get(tool.id);
+        if (first === undefined) {
+            positions.set(tool.id, entries.length);
+            updates.set(tool.id, [log]);
+            entries.push({ ...log, id: index });
+            calls.set(index, tool);
+        }
+        else {
+            const entry = entries[first];
+            const originalIndex = Number(entry.id);
+            focus.set(index, originalIndex);
+            calls.set(originalIndex, { ...calls.get(originalIndex), ...tool });
+            updates.get(tool.id).push(log);
+            entry.data = JsonValueSchema.parse({ entries: updates.get(tool.id) });
+        }
+    }
+    return { entries, calls, focus };
+}

package/dist/svelte/tool-widgets/runtime.d.ts

@@ -0,0 +1,21 @@
+import type { ToolWidgetLoader } from '@vibesdotdev/kit/components/tool-widgets';
+import { type ToolUIDescriptor, type ToolUIPlacement } from '../../schemas/ui.ts';
+export type SvelteToolWidgetModule = Awaited<ReturnType<ToolWidgetLoader>>;
+export interface SvelteToolWidgetDescriptorOptions {
+    toolId: string;
+    id?: string;
+    name?: string;
+    description?: string;
+    placement?: ToolUIPlacement;
+    tags?: string[];
+    hardware?: ToolUIDescriptor['hardware'];
+}
+export declare function createSvelteToolWidgetDescriptor(options: SvelteToolWidgetDescriptorOptions): ToolUIDescriptor;
+export declare function registerSvelteToolWidget(descriptor: ToolUIDescriptor, load: ToolWidgetLoader): Promise<void>;
+/**
+ * Registers the card with Kit's widget registry when the owner plugin module
+ * is evaluated (hosts that render without a resolver read that registry), and
+ * again when the tools/ui loader resolves (last registration wins).
+ */
+export declare function createSvelteToolWidgetLoader(descriptor: ToolUIDescriptor, load: ToolWidgetLoader): import("@vibesdotdev/kernel").AssetLoader;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/svelte/tool-widgets/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAEN,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAE3E,MAAM,WAAW,iCAAiC;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;CACxC;AAED,wBAAgB,gCAAgC,CAC/C,OAAO,EAAE,iCAAiC,GACxC,gBAAgB,CAclB;AAgBD,wBAAsB,wBAAwB,CAC7C,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,gBAAgB,GACpB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC3C,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,gBAAgB,6CAatB"}

package/dist/svelte/tool-widgets/runtime.js

@@ -0,0 +1,45 @@
+import { createRuntimeImplementation, loader, settle } from '@vibesdotdev/kernel';
+import { createToolUIDescriptor } from "../../schemas/ui.js";
+export function createSvelteToolWidgetDescriptor(options) {
+    return createToolUIDescriptor({
+        id: options.id ?? `${options.toolId}.svelte-widget`,
+        name: options.name ?? `${options.toolId} Svelte Widget`,
+        description: options.description ?? `Renders ${options.toolId} tool results in Svelte surfaces.`,
+        surfaces: ['web'],
+        role: 'widget',
+        targetToolId: options.toolId,
+        placement: options.placement,
+        tags: options.tags,
+        hardware: options.hardware,
+        enabled: true
+    });
+}
+// Kit is an optional peer: settle the import once so a host without Kit still
+// composes the tools/ui descriptors, and a host with Kit gets its widget
+// registry filled synchronously when an owner plugin module is imported.
+const kitToolWidgets = await settle(() => import('@vibesdotdev/kit/components/tool-widgets'));
+const registerKitToolWidget = kitToolWidgets.ok ? kitToolWidgets.value.registerToolWidget : undefined;
+function registerKitWidget(descriptor, load) {
+    registerKitToolWidget?.(descriptor.targetToolId, load, descriptor.placement ? { placement: descriptor.placement } : undefined);
+}
+export async function registerSvelteToolWidget(descriptor, load) {
+    const { registerToolWidget } = await import('@vibesdotdev/kit/components/tool-widgets');
+    registerToolWidget(descriptor.targetToolId, load, descriptor.placement ? { placement: descriptor.placement } : undefined);
+}
+/**
+ * Registers the card with Kit's widget registry when the owner plugin module
+ * is evaluated (hosts that render without a resolver read that registry), and
+ * again when the tools/ui loader resolves (last registration wins).
+ */
+export function createSvelteToolWidgetLoader(descriptor, load) {
+    registerKitWidget(descriptor, load);
+    return loader(descriptor.id, { kind: 'tools/ui', scope: 'browser' }, async () => {
+        registerKitWidget(descriptor, load);
+        const module = await load();
+        return createRuntimeImplementation({
+            kind: 'tools/ui',
+            id: descriptor.id,
+            implementation: { web: { component: module.default } }
+        });
+    });
+}

package/dist/svelte/tool-widgets/workspace-search-fallback.d.ts

@@ -0,0 +1,28 @@
+export type WorkspaceSearchFallbackHit = {
+    type?: string;
+    content: string;
+    location?: string;
+};
+export type WorkspaceSearchFallbackView = {
+    kind: 'hits';
+    hits: WorkspaceSearchFallbackHit[];
+} | {
+    kind: 'search';
+    query: string;
+    mode: string;
+    empty: string | null;
+} | {
+    kind: 'failed';
+    action: string;
+} | {
+    kind: 'unsupported';
+    action: string;
+};
+export type WorkspaceSearchFallbackTool = {
+    input?: unknown;
+    output?: unknown;
+    status?: string;
+    error?: string;
+};
+export declare function workspaceSearchFallbackView(tool: WorkspaceSearchFallbackTool): WorkspaceSearchFallbackView;
+//# sourceMappingURL=workspace-search-fallback.d.ts.map

package/dist/svelte/tool-widgets/workspace-search-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-search-fallback.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/workspace-search-fallback.ts"],"names":[],"mappings":"AAmCA,MAAM,MAAM,0BAA0B,GAAG;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACpC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,0BAA0B,EAAE,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,MAAM,2BAA2B,GAAG;IACzC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAqBF,wBAAgB,2BAA2B,CAC1C,IAAI,EAAE,2BAA2B,GAC/B,2BAA2B,CA0B7B"}

package/dist/svelte/tool-widgets/workspace-search-fallback.js

@@ -0,0 +1,77 @@
+/**
+ * Presentational model for tools' search-only `workspace-search` fallback card.
+ *
+ * Editor owns the full Atlas card (search, graph, symbol, rename, diagnostics,
+ * index-*, sync-status); this fallback covers search-kind calls on surfaces
+ * whose editor tarball predates `/svelte/plugin`. It never dumps blobs for
+ * search-kind calls: hits render as a list, failures as query context (the
+ * ToolCard chrome already shows the error), and anything else as a short
+ * state line. Non-search Atlas actions remain readable context cards while
+ * the richer Editor-owned renderer loads; first-party calls never fall back
+ * to a generic JSON dump.
+ */
+import * as z from 'zod/v4';
+import { isLiveToolStatus } from "./empty-state.js";
+import { readCardPayload, readCardPayloadList } from "./payload.js";
+const SearchInputFields = { action: z.string(), query: z.string(), mode: z.string() };
+const SearchOutputFields = { results: z.unknown(), ok: z.boolean(), error: z.string() };
+const SearchHitFields = { content: z.string(), type: z.string(), location: z.string() };
+/**
+ * True when the output blob would only echo the failure the ToolCard chrome
+ * already shows: the agent loop's `{ok:false, error}` envelope with the same
+ * message. Kit will own this helper once it publishes; tools keeps a local
+ * copy so this module never imports an unpublished cross-package symbol
+ * (isolated CI builds locked tarballs).
+ */
+function isRedundantFailureOutput(output, error) {
+    if (!error)
+        return false;
+    return output.get('ok') === false && output.get('error') === error;
+}
+function parseHits(output) {
+    return readCardPayloadList(SearchHitFields, output.get('results'))
+        .map((item) => {
+        const content = item.get('content') ?? '';
+        if (!content)
+            return null;
+        const hit = { content };
+        const type = item.get('type') ?? '';
+        const location = item.get('location') ?? '';
+        if (type)
+            hit.type = type;
+        if (location)
+            hit.location = location;
+        return hit;
+    })
+        .filter((hit) => hit !== null);
+}
+function isFailedStatus(status) {
+    return status === 'failed' || status === 'denied' || status === 'error' || status === 'timeout';
+}
+export function workspaceSearchFallbackView(tool) {
+    const input = readCardPayload(SearchInputFields, tool.input);
+    const output = readCardPayload(SearchOutputFields, tool.output);
+    const hits = parseHits(output);
+    if (hits.length > 0)
+        return { kind: 'hits', hits };
+    const action = input.get('action') ?? '';
+    const query = input.get('query') ?? '';
+    const mode = input.get('mode') ?? '';
+    const hasErrorText = Boolean(tool.error);
+    const failed = hasErrorText || isFailedStatus(tool.status);
+    // The descriptor's defaultAction is `search`: a missing action (or a bare
+    // query) is a search call, including the failed-validation `{}` shape.
+    const isSearch = !action || action === 'search' || query.length > 0;
+    if (isSearch) {
+        return {
+            kind: 'search',
+            query,
+            mode,
+            empty: failed ? null : isLiveToolStatus(tool.status) ? 'Running…' : 'No matching code.'
+        };
+    }
+    if (failed && isRedundantFailureOutput(output, tool.error)) {
+        return { kind: 'failed', action };
+    }
+    return { kind: 'unsupported', action };
+}

package/dist/svelte/tools-svelte.plugin.d.ts

@@ -0,0 +1,5 @@
+/** Kit chat cards. Import is cached; tests that clear the registry must call this again. */
+export declare function registerFirstPartyToolWidgets(): Promise<import("@vibesdotdev/kernel").AssetLoader[]>;
+declare const _default: import("@vibesdotdev/kernel").RuntimePlugin;
+export default _default;
+//# sourceMappingURL=tools-svelte.plugin.d.ts.map

package/dist/svelte/tools-svelte.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-svelte.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/tools-svelte.plugin.ts"],"names":[],"mappings":"AA+CA,4FAA4F;AAC5F,wBAAsB,6BAA6B,yDAOlD;;AAED,wBAWG"}

package/dist/svelte/tools-svelte.plugin.js

@@ -0,0 +1,52 @@
+import { createRuntimePlugin } from '@vibesdotdev/kernel';
+import { createSvelteToolWidgetDescriptor, createSvelteToolWidgetLoader, registerSvelteToolWidget } from "./tool-widgets/runtime.js";
+const FIRST_PARTY_WIDGETS = [
+    {
+        toolId: 'workspace-search',
+        load: () => import('./tool-widgets/WorkspaceSearchToolCard.svelte')
+    },
+    { toolId: 'workspace-fs', load: () => import('./tool-widgets/WorkspaceFsToolCard.svelte') },
+    { toolId: 'fetch', load: () => import('./tool-widgets/FetchToolCard.svelte') },
+    { toolId: 'run-command', load: () => import('./tool-widgets/RunCommandToolCard.svelte') },
+    { toolId: 'file-read', load: () => import('./tool-widgets/FileReadToolCard.svelte') },
+    { toolId: 'file-write', load: () => import('./tool-widgets/FileWriteToolCard.svelte') },
+    { toolId: 'git', load: () => import('./tool-widgets/GitToolCard.svelte') },
+    { toolId: 'sandbox-execute', load: () => import('./tool-widgets/SandboxExecuteToolCard.svelte') },
+    { toolId: 'calculate', load: () => import('./tool-widgets/CalculateToolCard.svelte') },
+    { toolId: 'tool-help', load: () => import('./tool-widgets/ToolHelpToolCard.svelte') },
+    { toolId: 'agent-execution', load: () => import('./tool-widgets/AgentExecutionToolCard.svelte') },
+    { toolId: 'ai-generate', load: () => import('./tool-widgets/AiGenerateToolCard.svelte') },
+    { toolId: 'ai-ocr-document', load: () => import('./tool-widgets/AiOcrDocumentToolCard.svelte') },
+    { toolId: 'generate-image', load: () => import('./tool-widgets/GenerateImageToolCard.svelte') },
+    { toolId: 'tool-search', load: () => import('./tool-widgets/ToolSearchToolCard.svelte') },
+    { toolId: 'tool-call', load: () => import('./tool-widgets/ToolCallToolCard.svelte') },
+    { toolId: 'workspace-create', load: () => import('./tool-widgets/WorkspaceHostToolCard.svelte') },
+    { toolId: 'workspace-destroy', load: () => import('./tool-widgets/WorkspaceHostToolCard.svelte') },
+    { toolId: 'workspace-status', load: () => import('./tool-widgets/WorkspaceHostToolCard.svelte') },
+    { toolId: 'workspace-exec', load: () => import('./tool-widgets/WorkspaceExecToolCard.svelte') },
+    { toolId: 'docs-audit-run', load: () => import('./tool-widgets/DocsAuditToolCard.svelte') },
+    { toolId: 'docs-audit-scan', load: () => import('./tool-widgets/DocsAuditToolCard.svelte') },
+    { toolId: 'docs-audit-write', load: () => import('./tool-widgets/DocsAuditToolCard.svelte') },
+    { toolId: 'docs', load: () => import('./tool-widgets/DocsToolCard.svelte') },
+    { toolId: 'example-echo', load: () => import('./tool-widgets/ExampleEchoToolCard.svelte') },
+    { toolId: 'codemod', load: () => import('./tool-widgets/CodemodToolCard.svelte') }
+];
+const firstPartyWidgetDescriptors = FIRST_PARTY_WIDGETS.map((widget) => createSvelteToolWidgetDescriptor({ toolId: widget.toolId }));
+const firstPartyWidgetLoaders = FIRST_PARTY_WIDGETS.map((widget, index) => createSvelteToolWidgetLoader(firstPartyWidgetDescriptors[index], widget.load));
+/** Kit chat cards. Import is cached; tests that clear the registry must call this again. */
+export async function registerFirstPartyToolWidgets() {
+    await Promise.all(FIRST_PARTY_WIDGETS.map((widget, index) => registerSvelteToolWidget(firstPartyWidgetDescriptors[index], widget.load)));
+    return firstPartyWidgetLoaders;
+}
+export default createRuntimePlugin({
+    id: 'tools-svelte',
+    name: 'Tools Module Svelte UI',
+    description: 'Registers Svelte-specific UI controls and components for tools',
+    dependencies: ['tools'],
+    kinds: [],
+    descriptors: [...firstPartyWidgetDescriptors],
+    loaders: [...firstPartyWidgetLoaders],
+    async onRegister() {
+        await registerFirstPartyToolWidgets();
+    }
+});

package/dist/svelte/tools-svelte.vessel.plugin.d.ts

@@ -0,0 +1,69 @@
+import * as z from 'zod/v4';
+export declare const toolsWorkspaceVesselAppDescriptor: {
+    readonly kind: "vessel/app";
+    readonly id: "tools.workspace";
+    readonly name: "Tools";
+    readonly description: "Inspect the actions available to agents and AI features.";
+    readonly owner: {
+        readonly packageName: "@vibesdotdev/tools/svelte";
+        readonly entrypoint: "./vessel.plugin";
+        readonly runtimeKind: "runtime/client";
+        readonly runtimeId: "tools";
+    };
+    readonly identity: {
+        readonly glyph: "lucide:wrench";
+        readonly accent: "azure";
+    };
+    readonly category: "feature";
+    readonly launch: {
+        readonly type: "vessel-surface";
+        readonly surfaceId: "tools.workspace";
+        readonly initialState: {};
+    };
+    readonly availability: {
+        readonly status: "unknown";
+        readonly summary: "Tools checks the canonical runtime catalog when opened.";
+    };
+    readonly defaultWindow: {
+        readonly x: 172;
+        readonly y: 104;
+        readonly width: 1040;
+        readonly height: 700;
+        readonly minWidth: 680;
+        readonly minHeight: 480;
+    };
+    readonly tags: readonly ["tools", "actions", "agents", "runtime"];
+    readonly workLocations: readonly ["computer", "cloud", "vessel"];
+};
+export declare const toolsWorkspaceVesselSurfaceDescriptor: {
+    kind: "vessel/surface";
+    id: string;
+    name: string;
+    description: string;
+    label: string;
+    surfaceKind: string;
+    owner: {
+        packageName: string;
+    };
+    contract: {
+        apiVersion: string;
+        stateSchemaId: string;
+        stateSchemaVersion: number;
+        stateSchema: z.ZodObject<{}, z.core.$strict>;
+    };
+    activation: string;
+    execution: string;
+    requiredCapabilities: {
+        id: string;
+        selectorId: string;
+        reason: string;
+    }[];
+    optionalCapabilities: never[];
+    primaryAudience: string;
+    secondaryAudiences: string[];
+    technicalLanguagePolicy: string;
+    promotionGate: string;
+};
+export declare const toolsSvelteVesselPlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default toolsSvelteVesselPlugin;
+//# sourceMappingURL=tools-svelte.vessel.plugin.d.ts.map

package/dist/svelte/tools-svelte.vessel.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-svelte.vessel.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/tools-svelte.vessel.plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAW5B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBpC,CAAC;AAEX,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhD,CAAC;AAEH,eAAO,MAAM,uBAAuB,6CAalC,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/dist/svelte/tools-svelte.vessel.plugin.js

@@ -0,0 +1,70 @@
+import { createRuntimeAsset, createRuntimePlugin, loader } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+const owner = {
+    packageName: '@vibesdotdev/tools/svelte',
+    entrypoint: './vessel.plugin',
+    runtimeKind: 'runtime/client',
+    runtimeId: 'tools'
+};
+const toolsWorkspaceStateSchema = z.object({}).strict();
+export const toolsWorkspaceVesselAppDescriptor = {
+    kind: 'vessel/app',
+    id: 'tools.workspace',
+    name: 'Tools',
+    description: 'Inspect the actions available to agents and AI features.',
+    owner,
+    identity: { glyph: 'lucide:wrench', accent: 'azure' },
+    category: 'feature',
+    launch: {
+        type: 'vessel-surface',
+        surfaceId: 'tools.workspace',
+        initialState: {}
+    },
+    availability: {
+        status: 'unknown',
+        summary: 'Tools checks the canonical runtime catalog when opened.'
+    },
+    defaultWindow: { x: 172, y: 104, width: 1040, height: 700, minWidth: 680, minHeight: 480 },
+    tags: ['tools', 'actions', 'agents', 'runtime'],
+    workLocations: ['computer', 'cloud', 'vessel']
+};
+export const toolsWorkspaceVesselSurfaceDescriptor = createRuntimeAsset({
+    kind: 'vessel/surface',
+    id: 'tools.workspace',
+    name: 'Tools workspace',
+    description: 'Canonical runtime tool catalog surface.',
+    label: 'Tools workspace',
+    surfaceKind: 'component',
+    owner: { packageName: '@vibesdotdev/tools/svelte' },
+    contract: {
+        apiVersion: '1.0.0',
+        stateSchemaId: 'tools.workspace.state',
+        stateSchemaVersion: 1,
+        stateSchema: toolsWorkspaceStateSchema
+    },
+    activation: 'on-open',
+    execution: 'host-trusted',
+    requiredCapabilities: [
+        {
+            id: 'tools/catalog',
+            selectorId: 'tools.catalog',
+            reason: 'List credential-dark tool summaries from the consumer runtime owner.'
+        }
+    ],
+    optionalCapabilities: [],
+    primaryAudience: 'workspace-user',
+    secondaryAudiences: ['host-integrator'],
+    technicalLanguagePolicy: 'hide',
+    promotionGate: 'A consumer host proves the real runtime tool catalog and truthful empty/error states.'
+});
+export const toolsSvelteVesselPlugin = createRuntimePlugin({
+    id: '@vibesdotdev/tools/svelte/vessel',
+    name: 'Tools Svelte Vessel Surface',
+    description: 'Owner-declared Tools workspace contribution for Vessel hosts.',
+    dependencies: ['vessel'],
+    descriptors: [toolsWorkspaceVesselAppDescriptor, toolsWorkspaceVesselSurfaceDescriptor],
+    loaders: [
+        loader(toolsWorkspaceVesselSurfaceDescriptor.id, { kind: 'vessel/surface', scope: 'browser' }, async () => ({ impl: (await import('./components/ToolsWorkspace.svelte')).default }))
+    ]
+});
+export default toolsSvelteVesselPlugin;

package/dist/testing/harness/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Universal Tool Testing Harness
+ *
+ * Exports all harness components for testing tools across different execution contexts.
+ */
+export { type TestScenario, type ScenarioFilterOptions, CONSUMER_DIRECT_SCENARIO, CONSUMER_WORKER_SCENARIO, CONSUMER_MCP_STDIO_SCENARIO, CONSUMER_MCP_HTTP_SCENARIO, CONSUMER_AGENT_SCENARIO, CLOUD_DIRECT_SCENARIO, CLOUD_WORKER_SCENARIO, CLOUD_MCP_SCENARIO, CLOUD_AGENT_SCENARIO, ALL_SCENARIOS, CONSUMER_SCENARIOS, CLOUD_SCENARIOS, MCP_SCENARIOS, SESSION_ISOLATION_SCENARIOS, AGENT_SCENARIOS, PM_AVAILABLE_SCENARIOS, WORKSPACE_AVAILABLE_SCENARIOS, UI_AVAILABLE_SCENARIOS, scenariosFor, getScenarioById, scenariosWithCapability, scenariosWithoutCapability } from './scenarios.ts';
+export { type McpTransportMock, type McpSessionContextMock, type MockSessionManager, type MockMcpSessionRegistry, createStdioTransportMock, createHttpTransportMock, createMockSessionManager, createSessionRegistryMock } from './transport-mocks.ts';
+export { type ToolFunction, type ScenarioResult, type HarnessOptions, type ContextBuildOptions, type HarnessContext, UniversalToolTestHarness, buildContextForScenario, createConsumerHarness, createCloudHarness, createMCPHarness, runToolAcrossAllScenarios, runToolInScenario } from './tool-test-harness.ts';
+export { type SessionIsolationTest, type IsolationTestOptions, type IsolationTestResult, type ExecutionEvent, type IsolatedOperationResult, type ParallelOperations, createIsolationTest, runIsolatedOperations, runParallelIsolatedOperations, assertNoStateLeakage, assertNoDataContamination, assertNoRaceConditions, assertExecutionOrder, testToolSessionIsolation, testToolParallelSafety } from './session-isolation.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/harness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/harness/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,2BAA2B,EAC3B,eAAe,EACf,sBAAsB,EACtB,6BAA6B,EAC7B,sBAAsB,EACtB,YAAY,EACZ,eAAe,EACf,uBAAuB,EACvB,0BAA0B,EAC1B,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,yBAAyB,EACzB,iBAAiB,EACjB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,6BAA6B,EAC7B,oBAAoB,EACpB,yBAAyB,EACzB,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,EACtB,MAAM,wBAAwB,CAAC"}