@scalar/agent-chat 0.3.1 → 0.3.3

package/dist/entities/index.js

@@ -1,21 +1,23 @@
 import { AgentErrorCodes as e } from "./error/constants.js";
 import { createError as E } from "./error/helpers.js";
-import { registryApiMetadata as A } from "./registry/document.js";
-import { ASK_FOR_AUTHENTICATION_TOOL_NAME as T, askForAuthenticationInputSchema as p } from "./tools/ask-for-authentication.js";
-import { TOOL_NAMESPACE_SLUG_DELIMITER as m } from "./tools/constants.js";
-import { EXECUTE_REQUEST_TOOL_NAME as S, executeRequestToolInputSchema as N } from "./tools/execute-request.js";
-import { GET_MINI_OPENAPI_SPEC_TOOL_NAME as x, getMiniOpenAPIDocToolInputSchema as f } from "./tools/get-mini-openapi-spec.js";
-import { GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME as P } from "./tools/get-openapi-spec-summary.js";
+import { MAX_PROMPT_SIZE as A } from "./prompt/constants.js";
+import { registryApiMetadata as T } from "./registry/document.js";
+import { ASK_FOR_AUTHENTICATION_TOOL_NAME as I, askForAuthenticationInputSchema as M } from "./tools/ask-for-authentication.js";
+import { TOOL_NAMESPACE_SLUG_DELIMITER as S } from "./tools/constants.js";
+import { EXECUTE_REQUEST_TOOL_NAME as N, executeRequestToolInputSchema as P } from "./tools/execute-request.js";
+import { GET_MINI_OPENAPI_SPEC_TOOL_NAME as f, getMiniOpenAPIDocToolInputSchema as n } from "./tools/get-mini-openapi-spec.js";
+import { GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME as L } from "./tools/get-openapi-spec-summary.js";
 export {
-  T as ASK_FOR_AUTHENTICATION_TOOL_NAME,
+  I as ASK_FOR_AUTHENTICATION_TOOL_NAME,
   e as AgentErrorCodes,
-  S as EXECUTE_REQUEST_TOOL_NAME,
-  x as GET_MINI_OPENAPI_SPEC_TOOL_NAME,
-  P as GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME,
-  m as TOOL_NAMESPACE_SLUG_DELIMITER,
-  p as askForAuthenticationInputSchema,
+  N as EXECUTE_REQUEST_TOOL_NAME,
+  f as GET_MINI_OPENAPI_SPEC_TOOL_NAME,
+  L as GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME,
+  A as MAX_PROMPT_SIZE,
+  S as TOOL_NAMESPACE_SLUG_DELIMITER,
+  M as askForAuthenticationInputSchema,
   E as createError,
-  N as executeRequestToolInputSchema,
-  f as getMiniOpenAPIDocToolInputSchema,
-  A as registryApiMetadata
+  P as executeRequestToolInputSchema,
+  n as getMiniOpenAPIDocToolInputSchema,
+  T as registryApiMetadata
 };

package/dist/entities/registry/document.d.ts

@@ -9,7 +9,9 @@ export declare const registryApiMetadata: z.ZodObject<{
     logoUrl: z.ZodNullable<z.ZodURL>;
     slug: z.ZodString;
 }, z.core.$strip>;
-export type ApiMetadata = z.infer<typeof registryApiMetadata>;
+export type ApiMetadata = z.infer<typeof registryApiMetadata> & {
+    removable?: boolean;
+};
 export type RegistryDocument = {
     namespace: string;
     slug: string;

package/dist/entities/registry/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/entities/registry/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE7D,MAAM,MAAM,gBAAgB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAElE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN;IACE,eAAe,EAAE,cAAc,EAAE,CAAA;IACjC,YAAY,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,CAAA;CACnD,CACF,CAAA"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/entities/registry/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAEvF,MAAM,MAAM,gBAAgB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAElE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN;IACE,eAAe,EAAE,cAAc,EAAE,CAAA;IACjC,YAAY,EAAE,WAAW,CAAC,YAAY,GAAG,SAAS,CAAA;CACnD,CACF,CAAA"}

package/dist/helpers.d.ts

@@ -1,69 +1,16 @@
-import type { MergedSecuritySchemes } from '@scalar/api-client/v2/blocks/scalar-auth-selector-block';
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
-import type { AuthenticationConfiguration } from '@scalar/types/api-reference';
 import type { WorkspaceStore } from '@scalar/workspace-store/client';
-import type { WorkspaceDocument } from '@scalar/workspace-store/schemas';
 import type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
-import type { OpenApiDocument, OperationObject, ParameterObject, PathItemObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import type { OperationObject, SecuritySchemeObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 import { type SecuritySchemes } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
-import type { ToolUIPart, UIDataTypes, UIMessagePart } from 'ai';
-import type { Tools } from './state/state.js';
-/** Combine pathItem and operation parameters into a single, dereferenced parameter array */
-export declare const combineParams: (pathParams?: PathItemObject["parameters"], operationParams?: OperationObject["parameters"]) => ParameterObject[];
-/**
- * Iterate through all available servers and pick the first one
- *
- * @example
- * getFirstServer([operation.servers, pathItem.servers, server])
- */
-export declare function getFirstServer(...availableServers: (ServerObject[] | ServerObject | undefined | null)[]): ServerObject | undefined;
-/** Determine if a message part is a tool */
-export declare function isToolPart(part: UIMessagePart<UIDataTypes, Tools>): part is ToolUIPart<Tools>;
-/**
- * Extracts the default scopes for a security scheme.
- * Only OAuth2 schemes can have default scopes via the x-default-scopes extension.
- */
-export declare const getDefaultScopes: (scheme: SecuritySchemeObject | undefined) => string[];
-/**
- * Determines the default security scheme to use for an operation.
- *
- * Priority order:
- * 1. User-configured preferred security scheme (if provided)
- * 2. First security requirement from the OpenAPI spec
- * 3. null (no security required)
- */
-export declare const getDefaultSecurity: (securityRequirements: SecurityRequirementObject[], preferredSecurityScheme: AuthenticationConfiguration["preferredSecurityScheme"], securitySchemes: MergedSecuritySchemes) => SecurityRequirementObject | null;
-/**
- * Find the intersection between which security is selected on the document and what this operation requires
- *
- * If there is no overlap, we return the first requirement
- */
-export declare const filterSelectedSecurity: (document: OpenApiDocument, operation: OperationObject | null, securitySchemes?: MergedSecuritySchemes) => SecuritySchemeObject[];
 export declare function getOperations(doc: Partial<OpenAPIV3_1.Document>): OperationObject[];
-/** Flattens all security requirements from a document */
-export declare function getSecurityFromDocument(document: WorkspaceDocument): SecuritySchemeObject[];
 /** Generate document settings from workspace store */
 export declare function createDocumentSettings(workspaceStore: WorkspaceStore): {
     [k: string]: {
-        activeServer: ServerObject | null;
+        activeServer: import("@scalar/workspace-store/schemas/v3.1/strict/server").ServerObject | null;
         securitySchemes: SecuritySchemeObject[];
     };
 };
-/**
- * Provides an interface to store and retrieve the selected client value
- * in local storage.
- */
-export declare const clientStorage: () => {
-    /**
-     * Gets the stored selected client from local storage.
-     */
-    get: () => string | null;
-    /**
-     * Stores the selected client value in local storage.
-     * @param value The value to store
-     */
-    set: (value: string) => void;
-};
 /**
  * Provides an interface to store and retrieve authentication scheme
  * information in local storage, including both the available schemes and
@@ -389,18 +336,6 @@ export declare const authStorage: () => {
      */
     setSelectedSchemes: (slug: string, value: XScalarSelectedSecurity) => void;
 };
-/**
- * Recursively merges secret values from stored data into the current schema.
- * Only merges secrets if the corresponding structure exists in the current schema.
- *
- * This function walks through both objects in parallel, copying any keys that
- * start with 'x-scalar-secret-' from the stored object to the current object,
- * but only if the path exists in the current schema.
- *
- * @param current - The current schema object (source of truth for structure)
- * @param stored - The stored object containing secret values to restore
- */
-export declare const mergeSecrets: (current: unknown, stored: unknown) => void;
 /**
  * Restores authentication secrets from local storage to the workspace store.
  *
@@ -415,4 +350,10 @@ export declare const restoreAuthSecretsFromStorage: ({ documentName, workspaceSt
     workspaceStore: WorkspaceStore;
 }) => void;
 export declare function safeParseJson(value: string): any;
+/**
+ * Wrap url with Scalar Proxy
+ *
+ * Skips wrapping if the url is localhost
+ */
+export declare function makeScalarProxyUrl(url: string): string;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAGpE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gFAAgF,CAAA;AAE7H,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,8DAA8D,CAAA;AACrE,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,8DAA8D,CAAA;AAErE,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,GACwB,eAAe,EAAE,CACxG;AAyBD,sDAAsD;AACtD,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,cAAc;;;;;EAgBpE;AAKD;;;;GAIG;AACH,eAAO,MAAM,WAAW;IAYpB;;OAEG;uBACgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIzB;;;OAGG;uBACgB,MAAM,SAAS,eAAe;IAGjD;;OAEG;+BACwB,MAAM;;;;;;IAIjC;;;OAGG;+BACwB,MAAM,SAAS,uBAAuB;CAIpE,CAAA;AAgDD;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GAAI,mCAG3C;IACD,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,cAAc,CAAA;CAC/B,KAAG,IAuCH,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,OAM1C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,UAqB7C"}

package/dist/helpers.js

@@ -1,111 +1,121 @@
 import { getSelectedServer as O } from "@scalar/api-client/v2/features/operation";
-import { getServers as E } from "@scalar/api-client/v2/helpers";
+import { getServers as x } from "@scalar/api-client/v2/helpers";
 import { isObject as l } from "@scalar/helpers/object/is-object";
-import { REFERENCE_LS_KEYS as d, safeLocalStorage as b } from "@scalar/helpers/object/local-storage";
-import { getResolvedRef as u } from "@scalar/workspace-store/helpers/get-resolved-ref";
-import { coerceValue as f } from "@scalar/workspace-store/schemas/typebox-coerce";
-import { XScalarSelectedSecuritySchema as v, SecuritySchemesSchema as j } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
-function R(t) {
-  return Object.values(t.paths ?? {}).flatMap((c) => Object.values(c ?? {}));
+import { REFERENCE_LS_KEYS as d, safeLocalStorage as v } from "@scalar/helpers/object/local-storage";
+import { getResolvedRef as h } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { coerceValue as y } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { XScalarSelectedSecuritySchema as b, SecuritySchemesSchema as E } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
+function P(e) {
+  return Object.values(e.paths ?? {}).flatMap((c) => Object.values(c ?? {}));
 }
-function x(t) {
-  const s = (t["x-scalar-selected-security"]?.selectedSchemes ?? []).flatMap((r) => Object.keys(r)), e = t.components?.securitySchemes;
-  return e ? s.reduce((r, n) => {
-    const o = e[n];
-    return o && r.push(u(o)), r;
+function j(e) {
+  const s = (e["x-scalar-selected-security"]?.selectedSchemes ?? []).flatMap((r) => Object.keys(r)), t = e.components?.securitySchemes;
+  return t ? s.reduce((r, n) => {
+    const o = t[n];
+    return o && r.push(h(o)), r;
   }, []) : [];
 }
-function w(t) {
+function C(e) {
   return Object.fromEntries(
-    Object.entries(t.workspace.documents).map(([c, s]) => {
-      const e = E(s.servers, {
+    Object.entries(e.workspace.documents).map(([c, s]) => {
+      const t = x(s.servers, {
         documentUrl: s?.["x-scalar-original-source-url"]
       });
       return [
         c,
         {
-          activeServer: O(s, e),
-          securitySchemes: x(s)
+          activeServer: O(s, t),
+          securitySchemes: j(s)
         }
       ];
     })
   );
 }
-const a = b(), y = () => {
-  const t = d.AUTH_SCHEMES, c = d.SELECTED_AUTH_SCHEMES, s = (e, r) => `${r}-${((o) => o === "schemas" ? t : c)(e)}`;
+const m = v(), f = () => {
+  const e = d.AUTH_SCHEMES, c = d.SELECTED_AUTH_SCHEMES, s = (t, r) => `${r}-${((o) => o === "schemas" ? e : c)(t)}`;
   return {
     /**
      * Retrieves and coerces the authentication schemes stored in local storage.
      */
-    getSchemas: (e) => {
-      const r = JSON.parse(a.getItem(s("schemas", e)) ?? "{}");
-      return f(j, r);
+    getSchemas: (t) => {
+      const r = JSON.parse(m.getItem(s("schemas", t)) ?? "{}");
+      return y(E, r);
     },
     /**
      * Stores the authentication schemes in local storage.
      * @param value The SecuritySchemes object to stringify and store.
      */
-    setSchemas: (e, r) => {
-      a.setItem(s("schemas", e), JSON.stringify(r));
+    setSchemas: (t, r) => {
+      m.setItem(s("schemas", t), JSON.stringify(r));
     },
     /**
      * Retrieves and coerces the selected authentication schemes stored in local storage.
      */
-    getSelectedSchemes: (e) => {
-      const r = JSON.parse(a.getItem(s("selectedSchemes", e)) ?? "{}");
-      return f(v, r);
+    getSelectedSchemes: (t) => {
+      const r = JSON.parse(m.getItem(s("selectedSchemes", t)) ?? "{}");
+      return y(b, r);
     },
     /**
      * Stores the user's selected authentication schemes in local storage.
      * @param value The XScalarSelectedSecurity object to stringify and store.
      */
-    setSelectedSchemes: (e, r) => {
-      a.setItem(s("selectedSchemes", e), JSON.stringify(r));
+    setSelectedSchemes: (t, r) => {
+      m.setItem(s("selectedSchemes", t), JSON.stringify(r));
     }
   };
-}, p = (t, c) => {
-  if (!(!l(t) || !l(c)))
-    for (const [s, e] of Object.entries(c)) {
-      if (typeof e != "object") {
-        t[s] = e;
+}, p = (e, c) => {
+  if (!(!l(e) || !l(c)))
+    for (const [s, t] of Object.entries(c)) {
+      if (typeof t != "object") {
+        e[s] = t;
         continue;
       }
-      p(u(t[s]), e);
+      p(h(e[s]), t);
     }
-}, I = (t, c) => Object.keys(t).every((s) => c.has(s)), k = (t, c) => t >= c ? c - 1 : t, D = ({
-  documentName: t,
+}, U = (e, c) => Object.keys(e).every((s) => c.has(s)), I = (e, c) => e >= c ? c - 1 : e, H = ({
+  documentName: e,
   workspaceStore: c
 }) => {
-  const s = y().getSchemas(t), e = c.workspace.documents[t];
-  if (!e)
+  const s = f().getSchemas(e), t = c.workspace.documents[e];
+  if (!t)
     return;
-  const n = y().getSelectedSchemes(t), o = new Set(Object.keys(e.components?.securitySchemes ?? {})), m = n["x-scalar-selected-security"]?.selectedSchemes?.filter((S) => I(S, o));
-  if (!e["x-scalar-selected-security"] && m && m.length > 0) {
-    const S = n["x-scalar-selected-security"]?.selectedIndex, i = k(S ?? 0, m.length);
-    e["x-scalar-selected-security"] = {
+  const n = f().getSelectedSchemes(e), o = new Set(Object.keys(t.components?.securitySchemes ?? {})), S = n["x-scalar-selected-security"]?.selectedSchemes?.filter((a) => U(a, o));
+  if (!t["x-scalar-selected-security"] && S && S.length > 0) {
+    const a = n["x-scalar-selected-security"]?.selectedIndex, i = I(a ?? 0, S.length);
+    t["x-scalar-selected-security"] = {
       selectedIndex: i,
-      selectedSchemes: m
+      selectedSchemes: S
     };
   }
-  const g = e.components?.securitySchemes ?? {};
-  for (const [S, i] of Object.entries(s)) {
-    const h = u(g[S]);
-    l(h) && p(h, i);
+  const g = t.components?.securitySchemes ?? {};
+  for (const [a, i] of Object.entries(s)) {
+    const u = h(g[a]);
+    l(u) && p(u, i);
   }
 };
-function F(t) {
+function M(e) {
   try {
-    return JSON.parse(t);
+    return JSON.parse(e);
   } catch {
     return;
   }
 }
+function N(e) {
+  try {
+    const c = new URL(e);
+    if (c.host === "localhost")
+      return e;
+    const s = new URLSearchParams({ scalar_url: c.toString() });
+    return new URL(`https://proxy.scalar.com/?${s}`).toString();
+  } catch {
+    return console.error(`Invalid URL provided: ${e}`), e;
+  }
+}
 export {
-  y as authStorage,
-  w as createDocumentSettings,
-  R as getOperations,
-  x as getSecurityFromDocument,
-  p as mergeSecrets,
-  D as restoreAuthSecretsFromStorage,
-  F as safeParseJson
+  f as authStorage,
+  C as createDocumentSettings,
+  P as getOperations,
+  N as makeScalarProxyUrl,
+  H as restoreAuthSecretsFromStorage,
+  M as safeParseJson
 };

package/dist/hooks/use-agent-key-documents.d.ts

@@ -0,0 +1,2 @@
+export declare function useAgentKeyDocuments(): void;
+//# sourceMappingURL=use-agent-key-documents.d.ts.map

package/dist/hooks/use-agent-key-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-agent-key-documents.d.ts","sourceRoot":"","sources":["../../src/hooks/use-agent-key-documents.ts"],"names":[],"mappings":"AAIA,wBAAgB,oBAAoB,SAkBnC"}

package/dist/hooks/use-agent-key-documents.js

@@ -0,0 +1,16 @@
+import { onMounted as a } from "vue";
+import { useState as m } from "../state/state.js";
+function i() {
+  const { api: t, addDocument: o, mode: n, getAgentKey: s } = m();
+  a(async () => {
+    if (n !== "full" || !s)
+      return;
+    const e = await t.getKeyDocuments();
+    e.success && e.data.documents.forEach(
+      ({ namespace: u, slug: c }) => o({ namespace: u, slug: c, removable: !1 })
+    );
+  });
+}
+export {
+  i as useAgentKeyDocuments
+};

package/dist/hooks/use-curated-documents.d.ts

@@ -0,0 +1,2 @@
+export declare function useCuratedDocuments(): void;
+//# sourceMappingURL=use-curated-documents.d.ts.map

package/dist/hooks/use-curated-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-curated-documents.d.ts","sourceRoot":"","sources":["../../src/hooks/use-curated-documents.ts"],"names":[],"mappings":"AAIA,wBAAgB,mBAAmB,SAYlC"}

package/dist/hooks/use-curated-documents.js

@@ -0,0 +1,12 @@
+import { onMounted as s } from "vue";
+import { useState as o } from "../state/state.js";
+function r() {
+  const { api: e, curatedDocuments: u } = o();
+  s(async () => {
+    const t = await e.getCuratedDocuments();
+    t.success && (u.value = t.data.results);
+  });
+}
+export {
+  r as useCuratedDocuments
+};

package/dist/hooks/use-search.d.ts

@@ -1,3 +1,4 @@
+import type { ApiMetadata } from '../entities/registry/document.js';
 export declare function useSearch(): {
     query: import("vue").WritableComputedRef<string, string>;
     results: import("vue").Ref<{
@@ -7,20 +8,15 @@ export declare function useSearch(): {
         currentVersion: string;
         logoUrl: string | null;
         slug: string;
-    }[], {
-        id: string;
-        title: string;
-        namespace: string;
-        currentVersion: string;
-        logoUrl: string | null;
-        slug: string;
-    }[] | {
+        removable?: boolean | undefined;
+    }[], ApiMetadata[] | {
         id: string;
         title: string;
         namespace: string;
         currentVersion: string;
         logoUrl: string | null;
         slug: string;
+        removable?: boolean | undefined;
     }[]>;
 };
 //# sourceMappingURL=use-search.d.ts.map

package/dist/hooks/use-search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-search.d.ts","sourceRoot":"","sources":["../../src/hooks/use-search.ts"],"names":[],"mappings":"AAOA,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;EAoCxB"}
+{"version":3,"file":"use-search.d.ts","sourceRoot":"","sources":["../../src/hooks/use-search.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAG/D,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;EAiCxB"}

package/dist/hooks/use-search.js

@@ -1,25 +1,21 @@
-import { useDebounceFn as m } from "@vueuse/core";
-import { ref as c, computed as f } from "vue";
-import { api as i } from "../api.js";
-import { useState as p } from "../state/state.js";
-function d() {
-  const { baseUrl: u, getAccessToken: n } = p(), s = c(""), r = m(async (e) => {
-    const o = await i({
-      baseUrl: u,
-      getAccessToken: n
-    }).search(e);
-    o.success && (t.value = o.data.results);
-  }, 200), a = f({
+import { useDebounceFn as a } from "@vueuse/core";
+import { ref as u, computed as f } from "vue";
+import { useState as i } from "../state/state.js";
+function h() {
+  const { api: c } = i(), s = u(""), t = a(async (e) => {
+    const o = await c.search(e);
+    o.success && (r.value = o.data.results);
+  }, 200), n = f({
     get: () => s.value,
     set: (e) => {
-      r(e), s.value = e;
+      t(e), s.value = e;
     }
-  }), t = c([]);
-  return r(""), {
-    query: a,
-    results: t
+  }), r = u([]);
+  return t(""), {
+    query: n,
+    results: r
   };
 }
 export {
-  d as useSearch
+  h as useSearch
 };

package/dist/hooks/use-term-and-conditions.d.ts

@@ -1,4 +1,3 @@
-export declare const TERMS_AND_CONDITIONS_LS_KEY = "scalar/agent-terms-accepted";
 export declare function useTermsAndConditions(): {
     accepted: import("vue").Ref<boolean, boolean>;
     accept: () => void;

package/dist/hooks/use-term-and-conditions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-term-and-conditions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-term-and-conditions.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,gCAAgC,CAAA;AAExE,wBAAgB,qBAAqB;;;EAapC"}
+{"version":3,"file":"use-term-and-conditions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-term-and-conditions.ts"],"names":[],"mappings":"AAIA,wBAAgB,qBAAqB;;;EAapC"}

package/dist/hooks/use-term-and-conditions.js

@@ -11,6 +11,5 @@ function n() {
   return { accepted: e, accept: o };
 }
 export {
-  t as TERMS_AND_CONDITIONS_LS_KEY,
   n as useTermsAndConditions
 };

package/dist/hooks/use-upload-tmp-document.d.ts

@@ -1,4 +1,3 @@
-import type { WorkspaceDocument } from '@scalar/workspace-store/schemas';
 export type UploadTmpDocumentState = {
     type: 'error';
     error: unknown;
@@ -9,8 +8,13 @@ export type UploadTmpDocumentState = {
 } | {
     type: 'done';
 };
+export declare function getTmpDocFromLocalStorage(): {
+    namespace: string;
+    slug: string;
+} | undefined;
 export declare function useUploadTmpDocument(): {
-    uploadTempDocument: (document: WorkspaceDocument) => Promise<{
+    uploadTempDocument: (document: string) => Promise<{
+        url: string;
         namespace: string;
         slug: string;
     } | undefined>;

package/dist/hooks/use-upload-tmp-document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-upload-tmp-document.d.ts","sourceRoot":"","sources":["../../src/hooks/use-upload-tmp-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAMxE,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpB,wBAAgB,oBAAoB;mCAeU,iBAAiB;;;;;EAgE9D"}
+{"version":3,"file":"use-upload-tmp-document.d.ts","sourceRoot":"","sources":["../../src/hooks/use-upload-tmp-document.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAQpB,wBAAgB,yBAAyB;;;cAYxC;AAED,wBAAgB,oBAAoB;mCAeU,MAAM;;;;;;EA4EnD"}

package/dist/hooks/use-upload-tmp-document.js

@@ -1,64 +1,86 @@
-import { ref as p } from "vue";
-import { z as n } from "zod/mini";
+import { ref as m } from "vue";
+import { z as o } from "zod/mini";
 import { useState as d } from "../state/state.js";
-function g() {
-  const u = d(), e = p();
-  function s(r) {
-    const t = `${u.baseUrl}${r}`;
-    if (t.startsWith("/")) return t;
-    const o = new URLSearchParams({ scalar_url: t.toString() });
-    return new URL(`https://proxy.scalar.com/?${o}`);
+const u = "scalar-tmp-doc";
+function g({ namespace: t, slug: e }) {
+  localStorage.setItem(u, JSON.stringify({ namespace: t, slug: e }));
+}
+function v() {
+  const t = localStorage.getItem(u);
+  if (t)
+    return o.object({
+      namespace: o.string(),
+      slug: o.string()
+    }).parse(JSON.parse(t));
+}
+function h() {
+  const t = d(), e = m();
+  function c(s) {
+    const a = `${t.baseUrl}${s}`;
+    if (a.startsWith("/")) return a;
+    const n = new URLSearchParams({ scalar_url: a.toString() });
+    return new URL(`https://proxy.scalar.com/?${n}`);
   }
-  async function c(r) {
+  async function l(s) {
     try {
       e.value = { type: "uploading" };
-      const t = await fetch(s("/core/share/upload/apis"), {
+      const a = await fetch(c("/core/share/upload/apis"), {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ document: JSON.stringify(r) })
+        body: JSON.stringify({ document: s })
       });
-      if (!t.ok) {
+      if (!a.ok) {
         e.value = {
           type: "error",
           error: "Failed to upload document."
         };
         return;
       }
-      const o = await t.json(), { success: i, data: a } = n.object({ namespace: n.string(), slug: n.string() }).safeParse(o);
-      if (!i) {
+      const n = await a.json(), { success: p, data: r } = o.object({ url: o.string(), namespace: o.string(), slug: o.string() }).safeParse(n);
+      if (!p) {
         e.value = {
           type: "error",
           error: "Failed to process document."
         };
         return;
       }
-      if (e.value = {
+      e.value = {
         type: "processing"
-      }, !(await fetch(
-        s(`/vector/registry/embeddings/${a.namespace}/${a.slug}`),
+      };
+      const i = await fetch(
+        c(`/vector/registry/embeddings/${r.namespace}/${r.slug}`),
         {
           method: "GET"
         }
-      )).ok) {
+      );
+      if (g({
+        namespace: r.namespace,
+        slug: r.slug
+      }), await t.addDocument({
+        namespace: r.namespace,
+        slug: r.slug,
+        removable: !1
+      }), !i.ok) {
         e.value = {
           type: "error",
           error: "Failed to embed document."
         };
         return;
       }
-      return e.value = { type: "done" }, setTimeout(() => {
+      return e.value = { type: "done" }, t.uploadedTmpDocumentUrl.value = r.url, setTimeout(() => {
         e.value = void 0;
-      }, 2e3), a;
+      }, 2e3), r;
     } catch {
       e.value = { type: "error", error: "Failed to upload document." };
       return;
     }
   }
   return {
-    uploadTempDocument: c,
+    uploadTempDocument: l,
     uploadState: e
   };
 }
 export {
-  g as useUploadTmpDocument
+  v as getTmpDocFromLocalStorage,
+  h as useUploadTmpDocument
 };

package/dist/package.json

@@ -10,7 +10,7 @@
     "url": "git+https://github.com/scalar/scalar.git",
     "directory": "packages/agent-chat"
   },
-  "version": "0.3.0",
+  "version": "0.3.3",
   "engines": {
     "node": ">=20"
   },