@ai-matrx/chat 0.4.22 → 0.4.24

package/dist/host/conversation-hooks.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Per-conversation host hooks (HOST-OWNED-SOURCE-PLAN §2.6, slice P28f).
+ *
+ * A database-backed host (the workflow studio) runs its conversations through
+ * the package's own doors — the mandate route, the real list, the real
+ * composer — and only adds what is truly its own, per conversation:
+ *
+ *   beforeSend         the pre-send gate. Runs before admission; returns the
+ *                      turn's `variables` + `context`, or refuses with the
+ *                      host's sentence (the words go back in the box).
+ *   held               a sentence that holds the composer ("a change is
+ *                      waiting for you on the canvas"); null = not held.
+ *   onEvent            the stream-event tap: every event of every turn on this
+ *                      conversation, once, in order, after the package applied
+ *                      it. Must not throw (a throw is reported and swallowed).
+ *   startConversation  the host names the next conversation's id; the client
+ *                      never mints one.
+ *   everyTurnThroughMandate
+ *                      every turn (not only turn 1) POSTs the mandate route,
+ *                      with the gate's variables + context — for a mandate
+ *                      whose provision checks guaranteed values on every turn.
+ *
+ * Kept OUT of Redux on purpose: these are functions and subscriptions owned by
+ * a mounted host surface, registered on mount and released on unmount.
+ */
+import type { TypedStreamEvent } from "@ai-matrx/agents/generated/stream-events";
+import { HostSendRefused } from "./source.js";
+export interface HostTurnExtras {
+    variables?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+export interface HostBeforeSendInput {
+    conversationId: string;
+    text: string;
+}
+export interface HostHeld {
+    get(): string | null;
+    subscribe(listener: () => void): () => void;
+}
+export interface HostStreamTapContext {
+    conversationId: string;
+    requestId: string;
+}
+export interface ConversationHostHooks {
+    beforeSend?: (input: HostBeforeSendInput) => Promise<HostTurnExtras | HostSendRefused>;
+    held?: HostHeld;
+    onEvent?: (event: TypedStreamEvent, ctx: HostStreamTapContext) => void;
+    startConversation?: () => Promise<string>;
+    everyTurnThroughMandate?: boolean;
+    /** How a stored user turn reads on screen (display only; the record is unchanged). */
+    displayUserText?: (text: string) => string;
+}
+/** Register a conversation's hooks. Returns the release; a newer registration for the same id wins. */
+export declare function registerConversationHooks(conversationId: string, hooks: ConversationHostHooks): () => void;
+export declare function getConversationHooks(conversationId: string): ConversationHostHooks | undefined;
+export type BeforeSendOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    sentence: string;
+};
+/**
+ * Run the conversation's pre-send gate. A conversation with no gate passes.
+ * A held conversation is refused with the held sentence. The gate's extras are
+ * kept for the request this turn assembles (`takeTurnExtras`).
+ */
+export declare function runBeforeSend(conversationId: string, text: string): Promise<BeforeSendOutcome>;
+/** The extras the gate returned for this turn; consumed once. */
+export declare function takeTurnExtras(conversationId: string): HostTurnExtras | null;
+/** Hand one stream event to the conversation's tap. Never throws. */
+export declare function tapStreamEvent(conversationId: string, requestId: string, event: unknown): void;
+/** Should this conversation's later turns also POST the mandate route? */
+export declare function continuesThroughMandate(conversationId: string): boolean;
+/** Ask the conversation's host for the next conversation id; null when it has no say. */
+export declare function startHostConversation(conversationId: string): Promise<string | null>;
+/** Subscribe to changes of this conversation's held sentence (registry + the host's own source). */
+export declare function subscribeConversationHeld(conversationId: string | null | undefined, listener: () => void): () => void;
+/** The held sentence right now, or null. */
+export declare function readConversationHeld(conversationId: string | null | undefined): string | null;

package/dist/host/conversation-hooks.js

@@ -0,0 +1,91 @@
+import { isHostSendRefused } from "./source.js";
+const hooksByConversation = /* @__PURE__ */ new Map();
+const extrasByConversation = /* @__PURE__ */ new Map();
+const registryListeners = /* @__PURE__ */ new Set();
+function notifyRegistry() {
+  for (const listener of registryListeners) listener();
+}
+function registerConversationHooks(conversationId, hooks) {
+  hooksByConversation.set(conversationId, hooks);
+  notifyRegistry();
+  return () => {
+    if (hooksByConversation.get(conversationId) === hooks) {
+      hooksByConversation.delete(conversationId);
+      extrasByConversation.delete(conversationId);
+      notifyRegistry();
+    }
+  };
+}
+function getConversationHooks(conversationId) {
+  return hooksByConversation.get(conversationId);
+}
+async function runBeforeSend(conversationId, text) {
+  const hooks = hooksByConversation.get(conversationId);
+  if (!hooks) return { ok: true };
+  const heldSentence = hooks.held?.get() ?? null;
+  if (heldSentence) return { ok: false, sentence: heldSentence };
+  if (!hooks.beforeSend) return { ok: true };
+  try {
+    const result = await hooks.beforeSend({ conversationId, text });
+    if (isHostSendRefused(result)) return { ok: false, sentence: result.message };
+    extrasByConversation.set(conversationId, result ?? {});
+    return { ok: true };
+  } catch (error) {
+    if (isHostSendRefused(error)) return { ok: false, sentence: error.message };
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, sentence: message || "This message could not be prepared. Nothing was sent." };
+  }
+}
+function takeTurnExtras(conversationId) {
+  const extras = extrasByConversation.get(conversationId) ?? null;
+  extrasByConversation.delete(conversationId);
+  return extras;
+}
+function tapStreamEvent(conversationId, requestId, event) {
+  const tap = hooksByConversation.get(conversationId)?.onEvent;
+  if (!tap) return;
+  try {
+    tap(event, { conversationId, requestId });
+  } catch (error) {
+    console.error(`[chat] the host's stream tap threw on conversation "${conversationId}"`, error);
+  }
+}
+function continuesThroughMandate(conversationId) {
+  return hooksByConversation.get(conversationId)?.everyTurnThroughMandate === true;
+}
+async function startHostConversation(conversationId) {
+  const start = hooksByConversation.get(conversationId)?.startConversation;
+  return start ? start() : null;
+}
+function subscribeConversationHeld(conversationId, listener) {
+  let release = subscribeOnce(conversationId, onChange);
+  function onChange() {
+    release();
+    release = subscribeOnce(conversationId, onChange);
+    listener();
+  }
+  return () => release();
+}
+function subscribeOnce(conversationId, listener) {
+  registryListeners.add(listener);
+  const held = conversationId ? hooksByConversation.get(conversationId)?.held : void 0;
+  const releaseHeld = held?.subscribe(listener);
+  return () => {
+    registryListeners.delete(listener);
+    releaseHeld?.();
+  };
+}
+function readConversationHeld(conversationId) {
+  return conversationId ? hooksByConversation.get(conversationId)?.held?.get() ?? null : null;
+}
+export {
+  continuesThroughMandate,
+  getConversationHooks,
+  readConversationHeld,
+  registerConversationHooks,
+  runBeforeSend,
+  startHostConversation,
+  subscribeConversationHeld,
+  takeTurnExtras,
+  tapStreamEvent
+};

package/dist/host/defaults/bare-block-dispatch.d.ts

@@ -0,0 +1,6 @@
+/** The block types the bare host gives a readable fallback (the app's cards replace them). */
+export declare const BARE_READABLE_BLOCK_TYPES: readonly ["decision", "artifact", "matrx", "input_remarks", "decision_questions", "decision_answers", "speech_script", "directive_receipt"];
+/** Markup → readable markdown: options become a list, every other tag is dropped, its text kept. */
+export declare function readableMarkup(content: string): string;
+/** Register the readable fallback for each type no host registered (idempotent). */
+export declare function registerBareReadableBlocks(): void;

package/dist/host/defaults/bare-block-dispatch.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  registerBlockDispatch,
+  resolveBlockDispatch
+} from "@ai-matrx/rich-content/display/chat-markdown/block-registry/block-dispatch";
+const BARE_READABLE_BLOCK_TYPES = [
+  "decision",
+  "artifact",
+  "matrx",
+  "input_remarks",
+  "decision_questions",
+  "decision_answers",
+  "speech_script",
+  "directive_receipt"
+];
+function attr(tag, name) {
+  return tag.match(new RegExp(`${name}\\s*=\\s*"([^"]*)"`, "i"))?.[1] ?? null;
+}
+function readableMarkup(content) {
+  return content.replace(/<option\b([^>]*)>([\s\S]*?)<\/option>/gi, (_m, attrs, text) => {
+    const label = attr(attrs, "label");
+    const body = text.trim();
+    return `
+- ${label && body && label !== body ? `**${label}** ${body}` : label || body}`;
+  }).replace(/<option\b([^>]*)\/>/gi, (_m, attrs) => `
+- ${attr(attrs, "label") ?? ""}`).replace(/<\/?[a-z_][\w:.-]*(?:\s[^>]*)?\/?>/gi, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function asJsonFence(value) {
+  return "```json\n" + JSON.stringify(value, null, 2) + "\n```";
+}
+function readable(ctx) {
+  const { block } = ctx;
+  const content = typeof block.content === "string" ? block.content : "";
+  const meta = block.metadata ?? {};
+  if (block.type === "matrx") {
+    try {
+      return ctx.renderBasicMarkdown(asJsonFence(JSON.parse(content)));
+    } catch {
+      return ctx.renderBasicMarkdown("```\n" + content + "\n```");
+    }
+  }
+  const title = typeof meta.artifactTitle === "string" ? `**${meta.artifactTitle}**
+
+` : "";
+  const text = readableMarkup(content);
+  if (text) return ctx.renderBasicMarkdown(title + text);
+  if (block.serverData !== void 0 && block.serverData !== null) return ctx.renderBasicMarkdown(title + asJsonFence(block.serverData));
+  return ctx.renderBasicMarkdown(title);
+}
+const READABLE = (ctx) => readable(ctx);
+function registerBareReadableBlocks() {
+  const missing = {};
+  for (const type of BARE_READABLE_BLOCK_TYPES) if (!resolveBlockDispatch(type)) missing[type] = READABLE;
+  if (Object.keys(missing).length) registerBlockDispatch(missing);
+}
+export {
+  BARE_READABLE_BLOCK_TYPES,
+  readableMarkup,
+  registerBareReadableBlocks
+};

package/dist/host/defaults/files-host.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The files engine's host for a bare chat host (P29a finding 3): a host that gave chat only a db
+ * still uploads attachments. `BareHostChrome` configures `@ai-matrx/media`'s files engine ONCE with
+ * the chat host's db, its server port (bearer + organization headers), the chat store (which mounts
+ * the `cloudFiles` slice) and its organization/identity/notify ports. A host that configured the
+ * engine itself (matrx-frontend: `features/files/files-host.ts`) is never overridden.
+ */
+import { type FilesServerClient, type FilesShareLinks } from "@ai-matrx/media/files/engine/host/configure";
+import type { ResolvedChatHost } from "../contract.js";
+/** The standalone files service (`matrx-files`): the routes it owns go there, everything else to the chat server. */
+export declare const DEFAULT_FILES_SERVICE_URL = "https://files.matrxserver.com";
+export declare function isFilesServiceRoute(path: string, method?: string): boolean;
+/** A failed call, carrying the status and the server's own words. */
+export declare class FilesRequestError extends Error {
+    readonly status: number | null;
+    readonly code: string;
+    readonly userMessage: string;
+    constructor(status: number | null, message: string, code?: string);
+}
+export declare function createDefaultFilesServer(host: () => ResolvedChatHost): FilesServerClient;
+/** Where a share link opens (the platform's own `/s/<token>` page). */
+export declare const DEFAULT_SHARE_LINK_ORIGIN = "https://aimatrx.com";
+/** Share links through the platform's own RPCs over the host's db (an attachment upload mints one). */
+export declare function createDefaultShareLinks(host: () => ResolvedChatHost): FilesShareLinks;
+/** Wire the files engine to a bare chat host, unless the host (or a test) already did. */
+export declare function configureBareFilesHost(host: ResolvedChatHost): void;

package/dist/host/defaults/files-host.js

@@ -0,0 +1,212 @@
+import {
+  configureFilesHost,
+  isFilesHostConfigured
+} from "@ai-matrx/media/files/engine/host/configure";
+import { getStoreSingleton } from "../../store/store-singleton.js";
+const DEFAULT_FILES_SERVICE_URL = "https://files.matrxserver.com";
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const FILES_SERVICE_ROUTES = [
+  [/^\/files\/upload\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [/^\/files\/bulk\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [/^\/files\/sync\/(?:changes|folders)\/?$/i, /* @__PURE__ */ new Set(["GET"])],
+  [new RegExp(`^/files/${UUID}/?$`, "i"), /* @__PURE__ */ new Set(["GET", "PATCH", "DELETE"])],
+  [new RegExp(`^/files/${UUID}/download/?$`, "i"), /* @__PURE__ */ new Set(["GET"])],
+  [new RegExp(`^/files/${UUID}/pdf-pages/?$`, "i"), /* @__PURE__ */ new Set(["POST"])],
+  [new RegExp(`^/files/${UUID}/restore/?$`, "i"), /* @__PURE__ */ new Set(["POST"])],
+  [new RegExp(`^/files/${UUID}/asset/?$`, "i"), /* @__PURE__ */ new Set(["GET"])],
+  [new RegExp(`^/files/${UUID}/share-links/?$`, "i"), /* @__PURE__ */ new Set(["GET", "POST"])],
+  [/^\/assets\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [/^\/assets\/presets\/?$/i, /* @__PURE__ */ new Set(["GET"])],
+  [/^\/assets\/(?:preview|preview\/multipart|pdf-compress|pdf-compress\/multipart)\/?$/i, /* @__PURE__ */ new Set(["POST"])],
+  [new RegExp(`^/assets/${UUID}/?$`, "i"), /* @__PURE__ */ new Set(["GET"])],
+  [/^\/share\/[^/]+(?:\/download)?\/?$/i, /* @__PURE__ */ new Set(["GET"])]
+];
+function isFilesServiceRoute(path, method = "GET") {
+  const pathname = path.split(/[?#]/, 1)[0];
+  return FILES_SERVICE_ROUTES.some(([pattern, methods]) => pattern.test(pathname) && methods.has(method.toUpperCase()));
+}
+class FilesRequestError extends Error {
+  status;
+  code;
+  userMessage;
+  constructor(status, message, code = "internal") {
+    super(message);
+    this.name = "FilesRequestError";
+    this.status = status;
+    this.code = code;
+    this.userMessage = message;
+  }
+}
+const trim = (url) => url.replace(/\/+$/, "");
+function createDefaultFilesServer(host) {
+  const filesBase = (override) => trim(override ?? DEFAULT_FILES_SERVICE_URL);
+  const serverBase = (override) => trim(override ?? host().server.baseUrl());
+  const baseFor = (path, override, method) => override ? trim(override) : isFilesServiceRoute(path, method) ? filesBase() : serverBase();
+  async function buildHeaders(opts, includeContentType) {
+    const requestId = opts.requestId ?? (globalThis.crypto?.randomUUID?.() ?? `${Date.now()}`);
+    const headers = { ...await host().server.headers?.() ?? {}, "X-Request-Id": requestId };
+    if (opts.organizationId) headers["X-Organization-Id"] = opts.organizationId;
+    if (opts.idempotencyKey) headers["Idempotency-Key"] = opts.idempotencyKey;
+    if (includeContentType) headers["Content-Type"] = "application/json";
+    return { headers, requestId };
+  }
+  const meta = (status, requestId, serverRequestId) => ({ requestId, status, serverRequestId });
+  async function failure(response) {
+    let message = `HTTP ${response.status}`;
+    let code = response.status >= 500 ? "internal" : "invalid_request";
+    try {
+      const body = await response.json();
+      const said = body.user_message ?? body.message ?? body.detail;
+      if (typeof said === "string" && said) message = said;
+      if (typeof body.error === "string") code = body.error;
+    } catch {
+    }
+    return new FilesRequestError(response.status, message, code);
+  }
+  async function send(method, path, opts = {}, body, form) {
+    const { headers, requestId } = await buildHeaders(opts, body !== void 0 && !form);
+    const response = await fetch(`${baseFor(path, opts.baseUrlOverride, method)}${path}`, {
+      method,
+      headers,
+      body: form ?? (body === void 0 ? void 0 : JSON.stringify(body)),
+      signal: opts.signal
+    });
+    if (!response.ok) throw await failure(response);
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : null;
+    return { data, meta: meta(response.status, requestId, response.headers.get("x-request-id")) };
+  }
+  async function download(path, opts = {}) {
+    const { headers, requestId } = await buildHeaders(opts, false);
+    const response = await fetch(`${baseFor(path, opts.baseUrlOverride, "GET")}${path}`, { headers, signal: opts.signal });
+    if (!response.ok) throw await failure(response);
+    const disposition = response.headers.get("content-disposition");
+    const filename = disposition?.match(/filename\*?=(?:UTF-8'')?"?([^";]+)"?/i)?.[1] ?? null;
+    return { blob: await response.blob(), meta: meta(response.status, requestId, response.headers.get("x-request-id")), filename: filename ? decodeURIComponent(filename) : null };
+  }
+  return {
+    resolveFilesBaseUrl: filesBase,
+    resolveBaseUrlForPath: baseFor,
+    buildHeaders: (opts, includeContentType) => buildHeaders(opts, includeContentType),
+    getJson: (path, opts) => send("GET", path, opts),
+    postJson: (path, body, opts) => send("POST", path, opts, body),
+    patchJson: (path, body, opts) => send("PATCH", path, opts, body),
+    putJson: (path, body, opts) => send("PUT", path, opts, body),
+    del: (path, opts) => send("DELETE", path, opts),
+    delJson: (path, body, opts) => send("DELETE", path, opts, body),
+    postMultipart: (path, form, opts) => send("POST", path, opts, void 0, form),
+    uploadWithProgress: (path, form, onProgress, opts = {}) => new Promise((resolve, reject) => {
+      void buildHeaders(opts, false).then(({ headers, requestId }) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open("POST", `${baseFor(path, opts.baseUrlOverride, "POST")}${path}`);
+        for (const [key, value] of Object.entries(headers)) xhr.setRequestHeader(key, value);
+        xhr.upload.addEventListener("progress", (event) => onProgress({ loaded: event.loaded, total: event.total }));
+        xhr.addEventListener("load", () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            try {
+              resolve({ data: xhr.responseText ? JSON.parse(xhr.responseText) : null, meta: meta(xhr.status, requestId, xhr.getResponseHeader("x-request-id")) });
+            } catch (error) {
+              reject(error);
+            }
+          } else {
+            let message = `Upload failed (${xhr.status}).`;
+            try {
+              const body = JSON.parse(xhr.responseText);
+              message = body.user_message ?? body.message ?? body.detail ?? message;
+            } catch {
+            }
+            reject(new FilesRequestError(xhr.status, message));
+          }
+        });
+        xhr.addEventListener("error", () => reject(new FilesRequestError(null, "Upload failed \u2014 check your connection.")));
+        xhr.addEventListener("abort", () => reject(new FilesRequestError(null, "Upload cancelled.", "cancelled")));
+        if (opts.signal) {
+          if (opts.signal.aborted) xhr.abort();
+          else opts.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+        }
+        xhr.send(form);
+      }, reject);
+    }),
+    downloadBlob: download,
+    downloadBlobWithProgress: async (path, onProgress, opts) => {
+      const result = await download(path, opts);
+      onProgress({ loaded: result.blob.size, total: result.blob.size });
+      return result;
+    }
+  };
+}
+const DEFAULT_SHARE_LINK_ORIGIN = "https://aimatrx.com";
+function createDefaultShareLinks(host) {
+  const rpc = (fn, args) => host().db.rpc(fn, args);
+  const shareLinkUrl = (token) => `${DEFAULT_SHARE_LINK_ORIGIN}/s/${token}`;
+  return {
+    shareLinkUrl,
+    async createShareLink(options) {
+      const { data, error } = await rpc("create_share_link", {
+        p_resource_type: options.resourceType,
+        p_resource_id: options.resourceId,
+        p_permission_level: options.permissionLevel ?? "viewer",
+        p_expires_at: options.expiresAt ?? void 0,
+        p_max_uses: options.maxUses ?? void 0,
+        p_label: options.label ?? void 0
+      });
+      if (error) return { success: false, error: error.message ?? "Failed to create link" };
+      const res = data;
+      if (!res?.success || !res.token) return { success: false, error: res?.error ?? "Failed to create link" };
+      return { success: true, token: res.token, shortToken: res.short_token ?? null, url: shareLinkUrl(res.token) };
+    },
+    async listShareLinks(resourceType, resourceId) {
+      const { data, error } = await rpc("list_share_links", { p_resource_type: resourceType, p_resource_id: resourceId });
+      if (error || !Array.isArray(data)) throw new Error(`Could not load this item's share links${error?.message ? `: ${error.message}` : "."}`);
+      return data.map((r) => ({
+        id: r.id,
+        token: r.token,
+        shortToken: r.short_token ?? null,
+        permissionLevel: r.permission_level,
+        label: r.label ?? null,
+        expiresAt: r.expires_at ?? null,
+        maxUses: r.max_uses ?? null,
+        useCount: r.use_count ?? 0,
+        isActive: r.is_active ?? false,
+        createdAt: r.created_at ?? null,
+        lastUsedAt: r.last_used_at ?? null
+      }));
+    },
+    async revokeShareLink(linkId) {
+      const { data, error } = await rpc("revoke_share_link", { p_link_id: linkId });
+      if (error) return { success: false, error: error.message };
+      const res = data;
+      return { success: !!res?.success, error: res?.error };
+    }
+  };
+}
+const UPLOAD_REASON = "upload this file";
+function configureBareFilesHost(host) {
+  if (isFilesHostConfigured()) return;
+  configureFilesHost({
+    db: host.db,
+    server: createDefaultFilesServer(() => host),
+    store: () => getStoreSingleton(),
+    scope: () => ({
+      userId: host.identity.current().userId ?? null,
+      organizationId: host.org.active()?.id ?? null,
+      projectId: null,
+      taskId: null
+    }),
+    shareLinks: createDefaultShareLinks(() => host),
+    ensureOrganizationContext: async ({ organizationId }) => organizationId ?? await host.org.require(UPLOAD_REASON),
+    notify: {
+      success: (message) => host.notify.success(message),
+      error: (message) => host.notify.error(message)
+    }
+  });
+}
+export {
+  DEFAULT_FILES_SERVICE_URL,
+  DEFAULT_SHARE_LINK_ORIGIN,
+  FilesRequestError,
+  configureBareFilesHost,
+  createDefaultFilesServer,
+  createDefaultShareLinks,
+  isFilesServiceRoute
+};

package/dist/host/defaults/resource-picker-menu.d.ts

@@ -0,0 +1,14 @@
+import type { Resource } from "../../agents/resources/types.js";
+import type { ResourcePickerViewId } from "../../agents/resources/picker-view-id.js";
+export interface DefaultResourcePickerMenuProps {
+    conversationId: string;
+    initialView?: ResourcePickerViewId;
+    initialUploadFiles?: readonly File[];
+    onResourceSelected?: (resource: Resource) => unknown;
+    onExitInitialView?: () => void;
+    onClose?: () => void;
+    [extra: string]: unknown;
+}
+/** The views this default draws; every other view is the host picker's. */
+export declare const DEFAULT_PICKER_VIEWS: ReadonlySet<ResourcePickerViewId>;
+export declare function DefaultResourcePickerMenu({ conversationId, initialView, initialUploadFiles, onResourceSelected, onExitInitialView, onClose, }: DefaultResourcePickerMenuProps): import("react").JSX.Element | null;

package/dist/host/defaults/resource-picker-menu.js

@@ -0,0 +1,117 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Button, Input } from "@ai-matrx/design-system";
+import { useUploadAgentResources } from "../../agents/components/inputs/resources/usePasteImageResource.js";
+const DEFAULT_PICKER_VIEWS = /* @__PURE__ */ new Set(["files", "webpage"]);
+function FilesView({ conversationId, initialUploadFiles, done }) {
+  const upload = useUploadAgentResources(conversationId);
+  const input = useRef(null);
+  const [dragging, setDragging] = useState(false);
+  const started = useRef(false);
+  const send = (files) => {
+    if (files.length === 0) return;
+    void upload(files);
+    done();
+  };
+  useEffect(() => {
+    if (started.current || !initialUploadFiles?.length) return;
+    started.current = true;
+    send([...initialUploadFiles]);
+  });
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `m-2 flex flex-col items-center gap-2 rounded-md border border-dashed p-4 text-sm ${dragging ? "border-primary bg-primary/5" : "border-border"}`,
+      "data-chat-default-picker": "files",
+      onDragOver: (event) => {
+        event.preventDefault();
+        setDragging(true);
+      },
+      onDragLeave: () => setDragging(false),
+      onDrop: (event) => {
+        event.preventDefault();
+        setDragging(false);
+        send(Array.from(event.dataTransfer.files));
+      },
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "Drop files here" }),
+        /* @__PURE__ */ jsx(Button, { type: "button", size: "sm", onClick: () => input.current?.click(), children: "Choose files" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref: input,
+            type: "file",
+            multiple: true,
+            hidden: true,
+            onChange: (event) => {
+              send(Array.from(event.target.files ?? []));
+              event.target.value = "";
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+function normalizeUrl(raw) {
+  const text = raw.trim();
+  if (!text) return null;
+  try {
+    const url = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(text) ? text : `https://${text}`);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function LinkView({ select }) {
+  const [text, setText] = useState("");
+  const url = normalizeUrl(text);
+  return /* @__PURE__ */ jsxs(
+    "form",
+    {
+      className: "flex items-center gap-2 p-2",
+      "data-chat-default-picker": "webpage",
+      onSubmit: (event) => {
+        event.preventDefault();
+        if (url) select(url);
+      },
+      children: [
+        /* @__PURE__ */ jsx(Input, { autoFocus: true, className: "h-8 text-sm", placeholder: "https://", value: text, onChange: (event) => setText(event.target.value) }),
+        /* @__PURE__ */ jsx(Button, { type: "submit", size: "sm", disabled: !url, children: "Attach" })
+      ]
+    }
+  );
+}
+function DefaultResourcePickerMenu({
+  conversationId,
+  initialView,
+  initialUploadFiles,
+  onResourceSelected,
+  onExitInitialView,
+  onClose
+}) {
+  const done = () => {
+    onExitInitialView?.();
+    onClose?.();
+  };
+  if (initialView === "files") {
+    return /* @__PURE__ */ jsx(FilesView, { conversationId, initialUploadFiles, done });
+  }
+  if (initialView === "webpage") {
+    return /* @__PURE__ */ jsx(
+      LinkView,
+      {
+        select: (url) => {
+          void onResourceSelected?.({ type: "webpage", data: url });
+          done();
+        }
+      }
+    );
+  }
+  return null;
+}
+export {
+  DEFAULT_PICKER_VIEWS,
+  DefaultResourcePickerMenu
+};

package/dist/host/defaults/setting-control-input.d.ts

@@ -0,0 +1,11 @@
+import type { ControlDefinition } from "../../agents/redux/agent-settings/types.js";
+export interface DefaultSettingControlInputProps {
+    settingKey: string;
+    control: ControlDefinition;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    disabled?: boolean;
+    id?: string;
+    [extra: string]: unknown;
+}
+export declare function DefaultSettingControlInput({ settingKey, control, value, onChange, disabled, id }: DefaultSettingControlInputProps): import("react").JSX.Element;