@meistrari/chat-ui-lang 0.3.0 → 0.4.0

package/dist/nuxt/runtime/components/widgets/table.d.vue.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    props: {
+        columns: unknown[];
+        caption?: string;
+    };
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/nuxt/runtime/components/widgets/table.vue

@@ -0,0 +1,41 @@
+<script setup>
+const props = defineProps({
+  props: { type: Object, required: true }
+});
+function toColumn(node) {
+  const column = node;
+  if (column?.typeName !== "Col" || !column.props)
+    return null;
+  return {
+    label: typeof column.props.label === "string" ? column.props.label : "",
+    values: Array.isArray(column.props.values) ? column.props.values.filter((value) => typeof value === "string" || typeof value === "number") : [],
+    align: column.props.align === "right" ? "right" : "left"
+  };
+}
+const columns = computed(() => (Array.isArray(props.props.columns) ? props.props.columns : []).map(toColumn).filter((column) => column !== null));
+const rowCount = computed(() => columns.value.reduce((max, column) => Math.max(max, column.values.length), 0));
+</script>
+
+<template>
+    <div data-openui="table">
+        <TelaTable>
+            <TelaTableCaption v-if="props.props.caption">
+                {{ props.props.caption }}
+            </TelaTableCaption>
+            <TelaTableHeader>
+                <TelaTableRow>
+                    <TelaTableHead v-for="(column, index) in columns" :key="index" :class="column.align === 'right' ? 'text-right' : ''">
+                        {{ column.label }}
+                    </TelaTableHead>
+                </TelaTableRow>
+            </TelaTableHeader>
+            <TelaTableBody>
+                <TelaTableRow v-for="row in rowCount" :key="row">
+                    <TelaTableCell v-for="(column, index) in columns" :key="index" :class="column.align === 'right' ? 'text-right' : ''">
+                        {{ column.values[row - 1] ?? "" }}
+                    </TelaTableCell>
+                </TelaTableRow>
+            </TelaTableBody>
+        </TelaTable>
+    </div>
+</template>

package/dist/nuxt/runtime/components/widgets/table.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    props: {
+        columns: unknown[];
+        caption?: string;
+    };
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/nuxt/runtime/context.d.ts

@@ -0,0 +1,30 @@
+import type { componentNames } from '@meistrari/chat-ui-lang';
+import type { ActionPlan, OpenUIError } from '@openuidev/lang-core';
+import type { Component, InjectionKey, Ref, VNode } from 'vue';
+export type OpenuiComponentName = (typeof componentNames)[number];
+export type RenderedNode = VNode | string | null | Array<VNode | string | null>;
+export interface OpenuiContext {
+    renderNode: (value: unknown) => RenderedNode;
+    /** Clicks are honoured only while the host allows it and the block is complete. */
+    interactive: Ref<boolean>;
+    /** Resolves once the action finished; returns false when it was rejected. A widget answers once: after an accepted send, `interactive` turns false. */
+    triggerAction: (label: string, plan?: ActionPlan) => Promise<boolean>;
+}
+export declare const OPENUI_CONTEXT_KEY: InjectionKey<OpenuiContext>;
+export type OpenuiErrorReporter = (errors: OpenUIError[], code: string) => void;
+/** Provided by OpenuiWidget, which forwards what widgets report while rendering (such as repeated form fields) as its `errors` event. */
+export declare const OPENUI_ERROR_REPORTER_KEY: InjectionKey<OpenuiErrorReporter>;
+export interface OpenuiHost {
+    /** Renders markdown prose for Markdown and Callout, with props `text` and `partial`; plain text when absent. */
+    prose?: Component;
+    /** Replaces the package widget of the same name, e.g. a FileCard bound to the host's file preview. */
+    components?: Partial<Record<OpenuiComponentName, Component>>;
+}
+/** A ref, so that a host an app replaces after mounting reaches the widgets that read it. */
+export declare const OPENUI_HOST_KEY: InjectionKey<Ref<OpenuiHost>>;
+export interface OpenuiFormState {
+    get: (name: string) => unknown;
+    set: (name: string, value: unknown) => void;
+}
+/** Provided by Form so its fields share one state bag. */
+export declare const OPENUI_FORM_KEY: InjectionKey<OpenuiFormState>;

package/dist/nuxt/runtime/context.js

@@ -0,0 +1,4 @@
+export const OPENUI_CONTEXT_KEY = Symbol("openui-context");
+export const OPENUI_ERROR_REPORTER_KEY = Symbol("openui-error-reporter");
+export const OPENUI_HOST_KEY = Symbol("openui-host");
+export const OPENUI_FORM_KEY = Symbol("openui-form");

package/dist/nuxt/runtime/form-fields.d.ts

@@ -0,0 +1,10 @@
+export type FormField = {
+    name: string;
+    label: string;
+    type: string;
+};
+/** Fields share state by name, so a repeated name keeps its first field and is reported. */
+export declare function collectFormFields(value: unknown): {
+    fields: FormField[];
+    duplicates: string[];
+};

package/dist/nuxt/runtime/form-fields.js

@@ -0,0 +1,30 @@
+const FIELD_TYPES = /* @__PURE__ */ new Set(["Input", "Select", "Checkbox"]);
+function collect(value, into) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      collect(item, into);
+    return;
+  }
+  const node = value;
+  if (!node || typeof node !== "object" || !node.props)
+    return;
+  if (node.typeName && FIELD_TYPES.has(node.typeName) && typeof node.props.name === "string") {
+    into.push({ name: node.props.name, label: typeof node.props.label === "string" ? node.props.label : node.props.name, type: node.typeName });
+    return;
+  }
+  for (const child of Object.values(node.props))
+    collect(child, into);
+}
+export function collectFormFields(value) {
+  const found = [];
+  collect(value, found);
+  const fields = [];
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const field of found) {
+    if (fields.some((existing) => existing.name === field.name))
+      duplicates.add(field.name);
+    else
+      fields.push(field);
+  }
+  return { fields, duplicates: [...duplicates] };
+}

package/dist/nuxt/runtime/program.d.ts

@@ -0,0 +1,15 @@
+import { createStore } from '@openuidev/lang-core';
+import type { ElementNode, OpenUIError } from '@openuidev/lang-core';
+import type { ComputedRef, Ref } from 'vue';
+export type OpenuiProgram = {
+    root: ComputedRef<ElementNode | null>;
+    errors: ComputedRef<OpenUIError[]>;
+    incomplete: ComputedRef<boolean>;
+    stateDefaults: ComputedRef<Record<string, unknown>>;
+    store: ReturnType<typeof createStore>;
+};
+/**
+ * Parses a streamed OpenUI Lang program. `code` may grow while `complete` is
+ * false; the parser diffs against its buffer so each chunk is parsed once.
+ */
+export declare function useOpenuiProgram(code: Ref<string>, complete: Ref<boolean>): OpenuiProgram;

package/dist/nuxt/runtime/program.js

@@ -0,0 +1,74 @@
+import { createStore, createStreamingParser, evaluateElementProps } from "@openuidev/lang-core";
+import { library } from "@meistrari/chat-ui-lang";
+import { computed, shallowRef, watch } from "vue";
+const schema = library.toJSONSchema();
+function parserErrors(result) {
+  return result.meta.errors.map((error) => ({
+    source: "parser",
+    code: error.code,
+    message: error.message,
+    component: error.component,
+    path: error.path || void 0,
+    statementId: error.statementId
+  }));
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export function useOpenuiProgram(code, complete) {
+  const parser = createStreamingParser(schema, library.root);
+  const store = createStore();
+  const storeRevision = shallowRef(0);
+  store.subscribe(() => {
+    storeRevision.value++;
+  });
+  const parsed = computed(() => {
+    if (!code.value.trim())
+      return { result: null, errors: [] };
+    try {
+      const result = parser.set(code.value, complete.value);
+      return { result, errors: parserErrors(result) };
+    } catch (error) {
+      return { result: null, errors: [{ source: "parser", code: "parse-exception", message: describe(error) }] };
+    }
+  });
+  const stateDefaults = computed(() => parsed.value.result?.stateDeclarations ?? {});
+  let seededDefaults = "";
+  watch(stateDefaults, (defaults) => {
+    const key = JSON.stringify(defaults);
+    if (key === seededDefaults)
+      return;
+    seededDefaults = key;
+    store.initialize(defaults, {});
+  }, { immediate: true });
+  const evaluated = computed(() => {
+    const result = parsed.value.result;
+    if (!result?.root)
+      return { root: null, errors: [] };
+    void storeRevision.value;
+    const errors = [];
+    const context = {
+      ctx: {
+        getState: (name) => store.get(name),
+        resolveRef: () => null,
+        // Without the library actions, @CopyText(...) evaluates to a plain node and its button sends the label instead.
+        actions: schema.actions
+      },
+      library,
+      store,
+      errors
+    };
+    try {
+      return { root: evaluateElementProps(result.root, context), errors };
+    } catch (error) {
+      return { root: result.root, errors: [...errors, { source: "runtime", code: "runtime-error", message: describe(error) }] };
+    }
+  });
+  return {
+    root: computed(() => evaluated.value.root),
+    errors: computed(() => [...parsed.value.errors, ...evaluated.value.errors]),
+    incomplete: computed(() => !complete.value || (parsed.value.result?.meta.incomplete ?? true)),
+    stateDefaults,
+    store
+  };
+}

package/dist/nuxt/runtime/registry.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'vue';
+import type { OpenuiComponentName } from './context.js';
+/** Every component the library exposes to the model must have a renderer here; hosts may replace any of them through OpenuiHost. */
+export declare const OPENUI_REGISTRY: Record<OpenuiComponentName, Component>;

package/dist/nuxt/runtime/registry.js

@@ -0,0 +1,44 @@
+import OpenuiBar from "./components/widgets/bar.vue";
+import OpenuiBarChart from "./components/widgets/bar-chart.vue";
+import OpenuiButton from "./components/widgets/button.vue";
+import OpenuiButtons from "./components/widgets/buttons.vue";
+import OpenuiCallout from "./components/widgets/callout.vue";
+import OpenuiCard from "./components/widgets/card.vue";
+import OpenuiCheckbox from "./components/widgets/checkbox.vue";
+import OpenuiCitation from "./components/widgets/citation.vue";
+import OpenuiCol from "./components/widgets/col.vue";
+import OpenuiFileCard from "./components/widgets/file-card.vue";
+import OpenuiForm from "./components/widgets/form.vue";
+import OpenuiImage from "./components/widgets/image.vue";
+import OpenuiInput from "./components/widgets/input.vue";
+import OpenuiMarkdown from "./components/widgets/markdown.vue";
+import OpenuiMetric from "./components/widgets/metric.vue";
+import OpenuiOption from "./components/widgets/option.vue";
+import OpenuiQuestion from "./components/widgets/question.vue";
+import OpenuiQuestions from "./components/widgets/questions.vue";
+import OpenuiSelect from "./components/widgets/select.vue";
+import OpenuiStack from "./components/widgets/stack.vue";
+import OpenuiTable from "./components/widgets/table.vue";
+export const OPENUI_REGISTRY = {
+  Stack: OpenuiStack,
+  Card: OpenuiCard,
+  Markdown: OpenuiMarkdown,
+  Callout: OpenuiCallout,
+  Metric: OpenuiMetric,
+  Col: OpenuiCol,
+  Table: OpenuiTable,
+  Bar: OpenuiBar,
+  BarChart: OpenuiBarChart,
+  Button: OpenuiButton,
+  Buttons: OpenuiButtons,
+  Input: OpenuiInput,
+  Select: OpenuiSelect,
+  Checkbox: OpenuiCheckbox,
+  Form: OpenuiForm,
+  Option: OpenuiOption,
+  Question: OpenuiQuestion,
+  Questions: OpenuiQuestions,
+  FileCard: OpenuiFileCard,
+  Image: OpenuiImage,
+  Citation: OpenuiCitation
+};

package/dist/nuxt/runtime/render.d.ts

@@ -0,0 +1,21 @@
+import type { ElementNode } from '@openuidev/lang-core';
+import type { PropType } from 'vue';
+import type { RenderedNode } from './context.js';
+/**
+ * One parsed element. Unknown components render nothing: the parser already
+ * reported them, and dropping a node is safer than showing raw text.
+ */
+export declare const OpenuiNode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<ElementNode>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<ElementNode>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare function renderNode(value: unknown): RenderedNode;

package/dist/nuxt/runtime/render.js

@@ -0,0 +1,48 @@
+import { defineComponent, h, inject, onErrorCaptured, ref, watch } from "vue";
+import { OPENUI_HOST_KEY } from "./context.js";
+import { OPENUI_REGISTRY } from "./registry.js";
+function isElementNode(value) {
+  return typeof value === "object" && value !== null && value.type === "element";
+}
+export const OpenuiNode = defineComponent({
+  name: "OpenuiNode",
+  props: {
+    node: { type: Object, required: true }
+  },
+  setup(props) {
+    const host = inject(OPENUI_HOST_KEY, ref({}));
+    const failed = ref(false);
+    onErrorCaptured((error) => {
+      console.error("[openui] widget render failed", { component: props.node.typeName, error });
+      failed.value = true;
+      return false;
+    });
+    watch(() => props.node, () => {
+      failed.value = false;
+    });
+    return () => {
+      const name = props.node.typeName;
+      const component = host.value.components?.[name] ?? OPENUI_REGISTRY[name];
+      if (!component || failed.value)
+        return null;
+      return h(component, { props: props.node.props, partial: props.node.partial });
+    };
+  }
+});
+export function renderNode(value) {
+  if (value == null)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (Array.isArray(value)) {
+    return value.flatMap((item, index) => {
+      const rendered = isElementNode(item) ? h(OpenuiNode, { node: item, key: item.statementId ?? `inline-${index}` }) : renderNode(item);
+      return Array.isArray(rendered) ? rendered : [rendered];
+    });
+  }
+  if (isElementNode(value))
+    return h(OpenuiNode, { node: value, key: value.statementId });
+  return null;
+}

package/dist/nuxt/runtime/use-openui-context.d.ts

@@ -0,0 +1,2 @@
+import type { OpenuiContext } from './context.js';
+export declare function useOpenuiContext(): OpenuiContext;

package/dist/nuxt/runtime/use-openui-context.js

@@ -0,0 +1,8 @@
+import { inject } from "vue";
+import { OPENUI_CONTEXT_KEY } from "./context.js";
+export function useOpenuiContext() {
+  const context = inject(OPENUI_CONTEXT_KEY, null);
+  if (!context)
+    throw new Error("OpenUI widgets must render inside OpenuiWidget");
+  return context;
+}

package/dist/nuxt/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type OpenuiHost } from '../../dist/nuxt/runtime/context.js'
+
+export { default, type registerOpenuiWidget } from './module.mjs'

package/dist/profiles.d.ts

@@ -0,0 +1,10 @@
+import type { UiLibrary } from './library';
+export declare const UI_PROFILES: readonly ["web", "slack"];
+export type UiProfile = (typeof UI_PROFILES)[number];
+export type UiProfileDefinition = {
+    library: UiLibrary;
+    /** Rules only this surface needs, appended to the shared prompt. */
+    rules: string[];
+    examples: string[];
+};
+export declare const profiles: Record<UiProfile, UiProfileDefinition>;

package/dist/prompt.d.ts

@@ -0,0 +1,5 @@
+import type { UiProfile } from './profiles';
+export declare function prompt(options: {
+    profile: UiProfile;
+    additionalRules?: string[];
+}): string;

package/dist/safe-url.d.ts

@@ -0,0 +1,2 @@
+/** Only absolute URLs with an explicit scheme; relative and protocol-relative values are rejected. */
+export declare function isSafeUrl(url: string): boolean;

package/dist/segments.d.ts

@@ -0,0 +1,16 @@
+export type AnswerSegment = {
+    kind: 'markdown';
+    text: string;
+} | {
+    kind: 'widget';
+    code: string;
+    complete: boolean;
+};
+export declare const WIDGET_PENDING_TEXT = "Montando um widget\u2026";
+/** Markdown and widget blocks in order; a widget still open at the end is incomplete. Empty markdown between blocks is dropped. */
+export declare function splitAnswer(content: string): AnswerSegment[];
+/**
+ * The streamed answer with every widget block, finished or still open, replaced by one placeholder line. It only grows as
+ * the text grows: a last line that may still become a widget opener is held back, so widget code is never shown.
+ */
+export declare function maskWidgets(content: string, placeholder?: string): string;

package/dist/slack.d.ts

@@ -0,0 +1,28 @@
+export type SlackBlock = Record<string, unknown>;
+export type SlackAnswer = {
+    /** The answer as plain markdown with every widget written out; Slack uses it for notifications and screen readers. */
+    text: string;
+    /** Empty when even the answer written out as prose does not fit `maxBlocks`: post `text` alone. */
+    blocks: SlackBlock[];
+};
+export type SlackRenderOptions = {
+    /** Renders markdown prose as blocks, the way the connector posts answers without widgets. */
+    prose: (text: string) => SlackBlock[];
+    /** Thread of the published answer. Without it buttons render as text, since a click could not continue the conversation. */
+    threadTs?: string;
+    /** Blocks left for the answer in its message; above it the answer goes out as text. */
+    maxBlocks: number;
+};
+export type SlackWidgetAction = {
+    threadTs: string;
+    message: string;
+};
+export declare function isSlackWidgetSendAction(actionId: string): boolean;
+export declare function isSlackWidgetLinkAction(actionId: string): boolean;
+/** The thread and message a widget button carries; null for any value this renderer did not write. */
+export declare function parseSlackWidgetAction(value: string): SlackWidgetAction | null;
+/**
+ * Block Kit for an answer that has widget blocks; null when it has none, so the caller keeps its plain path. Any program
+ * renders: what Slack cannot show (charts, forms, questions, files) is written out as text.
+ */
+export declare function renderSlackAnswer(content: string, options: SlackRenderOptions): SlackAnswer | null;

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const LIBRARY_VERSION = "0.4.0";
+export declare const UI_LANG_FENCE = "openui-lang";

package/dist/widget-context.d.ts

@@ -0,0 +1,13 @@
+export type WidgetContextDrop = {
+    reason: 'not-serialisable';
+    error: string;
+} | {
+    reason: 'too-large';
+    length: number;
+    limit: number;
+};
+/** The `@ToAssistant` context appended to the sent message; context that cannot travel is dropped and reported to onDrop. */
+export declare function formatWidgetContext(context: unknown, options?: {
+    limit?: number;
+    onDrop?: (drop: WidgetContextDrop) => void;
+}): string;

package/package.json

@@ -1,37 +1,78 @@
 {
-    "name": "@meistrari/chat-ui-lang",
-    "version": "0.3.0",
-    "type": "module",
-    "main": "./src/index.ts",
-    "types": "./src/index.ts",
-    "exports": {
-        ".": "./src/index.ts"
-    },
-    "files": [
-        "src",
-        "README.md"
-    ],
-    "scripts": {
-        "test": "bun test",
-        "typecheck": "tsc --noEmit",
-        "measure": "bun scripts/measure.ts"
-    },
-    "dependencies": {
-        "@openuidev/lang-core": "1.0.0",
-        "zod": "^4.1.13"
+  "name": "@meistrari/chat-ui-lang",
+  "version": "0.4.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
-    "devDependencies": {
-        "@anthropic-ai/sdk": "0.133.0",
-        "typescript": "5.9.3"
+    "./nuxt": {
+      "types": "./dist/nuxt/module.d.mts",
+      "import": "./dist/nuxt/module.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run build:catalogue && bun run build:nuxt",
+    "build:catalogue": "rm -rf dist && bun build src/index.ts --outdir dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+    "build:nuxt": "mkdir -p .nuxt && { [ -f .nuxt/tsconfig.json ] || printf '{}' > .nuxt/tsconfig.json; } && { [ -f .nuxt/tsconfig.server.json ] || printf '{}' > .nuxt/tsconfig.server.json; } && nuxt-module-build build --outDir dist/nuxt",
+    "prepack": "bun run build",
+    "test": "bun test ./test && vitest run",
+    "typecheck": "tsc --noEmit && nuxi prepare && vue-tsc --noEmit -p src/nuxt/tsconfig.json"
+  },
+  "dependencies": {
+    "@openuidev/lang-core": "1.0.0",
+    "zod": "^4.1.13"
+  },
+  "peerDependencies": {
+    "@meistrari/tela-build": "^1.79.0",
+    "nuxt": "^3.17.0 || ^4.0.0",
+    "vue": "^3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@meistrari/tela-build": {
+      "optional": true
     },
-    "description": "Catalogue of chat widgets the Tela agent may emit as OpenUI Lang, shared by chat-nuxt and agent-api",
-    "license": "UNLICENSED",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/meistrari/chat-app.git",
-        "directory": "packages/ui-lang"
+    "nuxt": {
+      "optional": true
     },
-    "publishConfig": {
-        "access": "public"
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "1.0.2",
+    "nuxt": "4.4.8",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4",
+    "vue-tsc": "3.2.7"
+  },
+  "description": "Catalogue of chat widgets the Tela agent may emit as OpenUI Lang, shared by chat-nuxt and agent-api, and its Nuxt renderer",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/meistrari/chat-app.git",
+    "directory": "packages/ui-lang"
+  },
+  "publishConfig": {
+    "access": "public",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./nuxt": {
+        "types": "./dist/nuxt/module.d.mts",
+        "import": "./dist/nuxt/module.mjs"
+      }
     }
+  }
 }

package/src/actions.ts

@@ -1,12 +0,0 @@
-import { defineAction } from '@openuidev/lang-core'
-import { z } from 'zod'
-
-export const CopyText = defineAction({
-    name: 'CopyText',
-    description: 'Copia um texto para a área de transferência do usuário.',
-    params: z.object({
-        text: z.string(),
-    }),
-})
-
-export const actions = { CopyText }

package/src/components/actions.ts

@@ -1,21 +0,0 @@
-import { action } from '@openuidev/lang-core'
-import { z } from 'zod'
-import { defineUiComponent } from '../define'
-
-export const Button = defineUiComponent({
-    name: 'Button',
-    description: 'Botão de ação. Com @ToAssistant envia uma mensagem como se o usuário tivesse digitado.',
-    props: z.object({
-        label: z.string(),
-        action: action().optional(),
-        variant: z.enum(['primary', 'secondary']).optional().describe('Padrão secondary; no máximo um primary por grupo'),
-    }),
-})
-
-export const Buttons = defineUiComponent({
-    name: 'Buttons',
-    description: 'Grupo horizontal de botões.',
-    props: z.object({
-        buttons: z.array(Button.ref).min(1).max(4),
-    }),
-})

package/src/components/chart.ts

@@ -1,22 +0,0 @@
-import { z } from 'zod'
-import { defineUiComponent } from '../define'
-
-export const Bar = defineUiComponent({
-    name: 'Bar',
-    description: 'Uma barra do gráfico.',
-    props: z.object({
-        label: z.string(),
-        value: z.number().describe('Valor numérico usado para o tamanho da barra'),
-        display: z.string().optional().describe('Valor formatado para exibir, ex: "R$ 1,2 mi"'),
-    }),
-})
-
-export const BarChart = defineUiComponent({
-    name: 'BarChart',
-    description: 'Gráfico de barras horizontais para comparar até 8 valores da mesma unidade.',
-    props: z.object({
-        title: z.string(),
-        bars: z.array(Bar.ref).min(2).max(8),
-        tone: z.enum(['neutral', 'positive', 'negative']).optional(),
-    }),
-})