@scalar/agent-chat 0.4.7 → 0.5.2

package/dist/helpers.d.ts

@@ -1,14 +1,13 @@
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { WorkspaceStore } from '@scalar/workspace-store/client';
-import type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
-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 Auth } from '@scalar/workspace-store/entities/auth';
+import type { OperationObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 export declare function getOperations(doc: Partial<OpenAPIV3_1.Document>): OperationObject[];
 /** Generate document settings from workspace store */
 export declare function createDocumentSettings(workspaceStore: WorkspaceStore): {
     [k: string]: {
         activeServer: import("@scalar/workspace-store/schemas/v3.1/strict/server").ServerObject | null;
-        securitySchemes: SecuritySchemeObject[];
+        securitySchemes: import("@scalar/api-client/v2/blocks/scalar-auth-selector-block").SecuritySchemeObjectSecret[];
     };
 };
 /**
@@ -20,52 +19,26 @@ export declare const authStorage: () => {
     /**
      * Retrieves and coerces the authentication schemes stored in local storage.
      */
-    getSchemas: (slug: string) => {
-        [x: string]: ({
-            description?: string | undefined;
-        } & {
-            'x-scalar-secret-token': string;
-        } & {
-            type: "apiKey";
-            in: "cookie" | "query" | "header";
-            name: string;
-        }) | ({
-            description?: string | undefined;
-        } & {
-            'x-scalar-secret-token': string;
-        } & {
-            'x-scalar-secret-username': string;
-            'x-scalar-secret-password': string;
-        } & {
-            bearerFormat?: string | undefined;
-            type: "http";
-            scheme: "basic" | "bearer";
-        }) | ({
-            description?: string | undefined;
-        } & {
-            type: "oauth2";
-            flows: {
+    getAuth: (slug: string) => {
+        secrets: {
+            [x: string]: ({
+                type: "apiKey";
+            } & {
+                'x-scalar-secret-token': string;
+            }) | ({
+                type: "http";
+            } & {
+                'x-scalar-secret-token': string;
+            } & {
+                'x-scalar-secret-username': string;
+                'x-scalar-secret-password': string;
+            }) | ({
+                type: "oauth2";
+            } & {
                 password?: ({
-                    refreshUrl: string;
-                    scopes: {
-                        [x: string]: string;
-                    };
-                } & {
                     'x-scalar-secret-client-id': string;
                 } & {
                     'x-scalar-secret-token': string;
-                } & {
-                    'x-scalar-security-query'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-scalar-security-body'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-tokenName'?: string | undefined;
-                } & {
-                    tokenUrl: string;
                 } & {
                     'x-scalar-secret-username': string;
                     'x-scalar-secret-password': string;
@@ -75,266 +48,54 @@ export declare const authStorage: () => {
                     'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 }) | undefined;
                 implicit?: ({
-                    refreshUrl: string;
-                    scopes: {
-                        [x: string]: string;
-                    };
-                } & {
                     'x-scalar-secret-client-id': string;
                 } & {
                     'x-scalar-secret-token': string;
-                } & {
-                    'x-scalar-security-query'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-scalar-security-body'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-tokenName'?: string | undefined;
-                } & {
-                    authorizationUrl: string;
                 } & {
                     'x-scalar-secret-redirect-uri': string;
                 }) | undefined;
                 clientCredentials?: ({
-                    refreshUrl: string;
-                    scopes: {
-                        [x: string]: string;
-                    };
-                } & {
                     'x-scalar-secret-client-id': string;
                 } & {
                     'x-scalar-secret-token': string;
-                } & {
-                    'x-scalar-security-query'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-scalar-security-body'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-tokenName'?: string | undefined;
-                } & {
-                    tokenUrl: string;
                 } & {
                     'x-scalar-secret-client-secret': string;
                 } & {
                     'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 }) | undefined;
                 authorizationCode?: ({
-                    refreshUrl: string;
-                    scopes: {
-                        [x: string]: string;
-                    };
-                } & {
                     'x-scalar-secret-client-id': string;
                 } & {
                     'x-scalar-secret-token': string;
-                } & {
-                    'x-scalar-security-query'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-scalar-security-body'?: {
-                        [x: string]: string;
-                    } | undefined;
-                } & {
-                    'x-tokenName'?: string | undefined;
-                } & {
-                    authorizationUrl: string;
-                    tokenUrl: string;
                 } & {
                     'x-scalar-secret-client-secret': string;
                 } & {
                     'x-scalar-secret-redirect-uri': string;
-                } & {
-                    'x-usePkce': "SHA-256" | "plain" | "no";
                 } & {
                     'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 }) | undefined;
-            };
-        } & {
-            'x-default-scopes'?: string[] | undefined;
-        }) | ({
-            description?: string | undefined;
-        } & {
-            type: "openIdConnect";
-            openIdConnectUrl: string;
-        }) | ({
-            description?: string | undefined;
-            summary?: string | undefined;
-            $ref: string;
-        } & {
-            $status?: "loading" | "error" | undefined;
-            $global?: boolean | undefined;
-        } & {
-            '$ref-value': ({
-                description?: string | undefined;
-            } & {
-                'x-scalar-secret-token': string;
-            } & {
-                type: "apiKey";
-                in: "cookie" | "query" | "header";
-                name: string;
-            }) | ({
-                description?: string | undefined;
-            } & {
-                'x-scalar-secret-token': string;
-            } & {
-                'x-scalar-secret-username': string;
-                'x-scalar-secret-password': string;
-            } & {
-                bearerFormat?: string | undefined;
-                type: "http";
-                scheme: "basic" | "bearer";
-            }) | ({
-                description?: string | undefined;
-            } & {
-                type: "oauth2";
-                flows: {
-                    password?: ({
-                        refreshUrl: string;
-                        scopes: {
-                            [x: string]: string;
-                        };
-                    } & {
-                        'x-scalar-secret-client-id': string;
-                    } & {
-                        'x-scalar-secret-token': string;
-                    } & {
-                        'x-scalar-security-query'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-scalar-security-body'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-tokenName'?: string | undefined;
-                    } & {
-                        tokenUrl: string;
-                    } & {
-                        'x-scalar-secret-username': string;
-                        'x-scalar-secret-password': string;
-                    } & {
-                        'x-scalar-secret-client-secret': string;
-                    } & {
-                        'x-scalar-credentials-location'?: "header" | "body" | undefined;
-                    }) | undefined;
-                    implicit?: ({
-                        refreshUrl: string;
-                        scopes: {
-                            [x: string]: string;
-                        };
-                    } & {
-                        'x-scalar-secret-client-id': string;
-                    } & {
-                        'x-scalar-secret-token': string;
-                    } & {
-                        'x-scalar-security-query'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-scalar-security-body'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-tokenName'?: string | undefined;
-                    } & {
-                        authorizationUrl: string;
-                    } & {
-                        'x-scalar-secret-redirect-uri': string;
-                    }) | undefined;
-                    clientCredentials?: ({
-                        refreshUrl: string;
-                        scopes: {
-                            [x: string]: string;
-                        };
-                    } & {
-                        'x-scalar-secret-client-id': string;
-                    } & {
-                        'x-scalar-secret-token': string;
-                    } & {
-                        'x-scalar-security-query'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-scalar-security-body'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-tokenName'?: string | undefined;
-                    } & {
-                        tokenUrl: string;
-                    } & {
-                        'x-scalar-secret-client-secret': string;
-                    } & {
-                        'x-scalar-credentials-location'?: "header" | "body" | undefined;
-                    }) | undefined;
-                    authorizationCode?: ({
-                        refreshUrl: string;
-                        scopes: {
-                            [x: string]: string;
-                        };
-                    } & {
-                        'x-scalar-secret-client-id': string;
-                    } & {
-                        'x-scalar-secret-token': string;
-                    } & {
-                        'x-scalar-security-query'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-scalar-security-body'?: {
-                            [x: string]: string;
-                        } | undefined;
-                    } & {
-                        'x-tokenName'?: string | undefined;
-                    } & {
-                        authorizationUrl: string;
-                        tokenUrl: string;
-                    } & {
-                        'x-scalar-secret-client-secret': string;
-                    } & {
-                        'x-scalar-secret-redirect-uri': string;
-                    } & {
-                        'x-usePkce': "SHA-256" | "plain" | "no";
-                    } & {
-                        'x-scalar-credentials-location'?: "header" | "body" | undefined;
-                    }) | undefined;
-                };
-            } & {
-                'x-default-scopes'?: string[] | undefined;
-            }) | ({
-                description?: string | undefined;
-            } & {
-                type: "openIdConnect";
-                openIdConnectUrl: string;
             });
-        });
+        };
+        selected: {
+            document?: {
+                selectedIndex: number;
+                selectedSchemes: {}[];
+            } | undefined;
+            path?: {
+                [x: string]: {
+                    [x: string]: {
+                        selectedIndex: number;
+                        selectedSchemes: {}[];
+                    };
+                };
+            } | undefined;
+        };
     };
     /**
      * Stores the authentication schemes in local storage.
-     * @param value The SecuritySchemes object to stringify and store.
-     */
-    setSchemas: (slug: string, value: SecuritySchemes) => void;
-    /**
-     * Retrieves and coerces the selected authentication schemes stored in local storage.
-     */
-    getSelectedSchemes: (slug: string) => {
-        'x-scalar-selected-security'?: {
-            selectedSchemes: {}[];
-            selectedIndex: number;
-        } | undefined;
-    };
-    /**
-     * Stores the user's selected authentication schemes in local storage.
-     * @param value The XScalarSelectedSecurity object to stringify and store.
+     * @param value The Auth object to stringify and store.
      */
-    setSelectedSchemes: (slug: string, value: XScalarSelectedSecurity) => void;
+    setAuth: (slug: string, value: Auth) => void;
 };
 /**
  * Restores authentication secrets from local storage to the workspace store.

package/dist/helpers.d.ts.map

@@ -1 +1 @@
-{"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,UAmB7C"}
+{"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;AAEpE,OAAO,EAAE,KAAK,IAAI,EAAc,MAAM,uCAAuC,CAAA;AAG7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAEnG,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,GACwB,eAAe,EAAE,CACxG;AAOD,sDAAsD;AACtD,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,cAAc;;;;;EAgBpE;AAKD;;;;GAIG;AACH,eAAO,MAAM,WAAW;IAMpB;;OAEG;oBACa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAItB;;;OAGG;oBACa,MAAM,SAAS,IAAI;CAItC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GAAI,mCAG3C;IACD,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,cAAc,CAAA;CAC/B,KAAG,IAIH,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,OAM1C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,UAmB7C"}

package/dist/helpers.js

@@ -1,120 +1,78 @@
-import { getSelectedServer as O } from "@scalar/api-client/v2/features/operation";
-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 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 E, SecuritySchemesSchema as b } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
-function P(e) {
-  return Object.values(e.paths ?? {}).flatMap((c) => Object.values(c ?? {}));
+import { mergeSecurity as a } from "@scalar/api-client/v2/blocks/scalar-auth-selector-block";
+import { getSelectedServer as c } from "@scalar/api-client/v2/features/operation";
+import { getServers as n } from "@scalar/api-client/v2/helpers";
+import { safeLocalStorage as u, REFERENCE_LS_KEYS as i } from "@scalar/helpers/object/local-storage";
+import { AuthSchema as m } from "@scalar/workspace-store/entities/auth";
+import { coerceValue as h } from "@scalar/workspace-store/schemas/typebox-coerce";
+function U(t) {
+  return Object.values(t.paths ?? {}).flatMap((r) => Object.values(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 p(t, r, e) {
+  return Object.values(a(r?.components?.securitySchemes, {}, e, t));
 }
-function C(e) {
+function x(t) {
   return Object.fromEntries(
-    Object.entries(e.workspace.documents).map(([c, s]) => {
-      const t = x(s.servers, {
-        documentUrl: s?.["x-scalar-original-source-url"]
+    Object.entries(t.workspace.documents).map(([r, e]) => {
+      const s = n(e.servers, {
+        documentUrl: e?.["x-scalar-original-source-url"]
       });
       return [
-        c,
+        r,
         {
-          activeServer: O(s, t),
-          securitySchemes: j(s)
+          activeServer: c(e, s),
+          securitySchemes: p(r, e, t.auth)
         }
       ];
     })
   );
 }
-const m = v(), f = () => {
-  const e = d.AUTH_SCHEMES, c = d.SELECTED_AUTH_SCHEMES, s = (t, r) => `${r}-${((o) => o === "schemas" ? e : c)(t)}`;
+const o = u(), S = () => {
+  const t = (r) => `${i.AUTH}-${r}`;
   return {
     /**
      * Retrieves and coerces the authentication schemes stored in local storage.
      */
-    getSchemas: (t) => {
-      const r = JSON.parse(m.getItem(s("schemas", t)) ?? "{}");
-      return y(b, r);
+    getAuth: (r) => {
+      const e = JSON.parse(o.getItem(t(r)) ?? "{}");
+      return h(m, e);
     },
     /**
      * Stores the authentication schemes in local storage.
-     * @param value The SecuritySchemes object to stringify and store.
+     * @param value The Auth object to stringify and store.
      */
-    setSchemas: (t, r) => {
-      m.setItem(s("schemas", t), JSON.stringify(r));
-    },
-    /**
-     * Retrieves and coerces the selected authentication schemes stored in local storage.
-     */
-    getSelectedSchemes: (t) => {
-      const r = JSON.parse(m.getItem(s("selectedSchemes", t)) ?? "{}");
-      return y(E, r);
-    },
-    /**
-     * Stores the user's selected authentication schemes in local storage.
-     * @param value The XScalarSelectedSecurity object to stringify and store.
-     */
-    setSelectedSchemes: (t, r) => {
-      m.setItem(s("selectedSchemes", t), JSON.stringify(r));
+    setAuth: (r, e) => {
+      o.setItem(t(r), JSON.stringify(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(h(e[s]), t);
-    }
-}, I = (e, c) => Object.keys(e).every((s) => c.has(s)), U = (e, c) => e >= c ? c - 1 : e, H = ({
-  documentName: e,
-  workspaceStore: c
+}, A = ({
+  documentName: t,
+  workspaceStore: r
 }) => {
-  const s = f().getSchemas(e), t = c.workspace.documents[e];
-  if (!t)
-    return;
-  const n = f().getSelectedSchemes(e), o = new Set(Object.keys(t.components?.securitySchemes ?? {})), S = n["x-scalar-selected-security"]?.selectedSchemes?.filter((a) => I(a, o));
-  if (!t["x-scalar-selected-security"] && S && S.length > 0) {
-    const a = n["x-scalar-selected-security"]?.selectedIndex, i = U(a ?? 0, S.length);
-    t["x-scalar-selected-security"] = {
-      selectedIndex: i,
-      selectedSchemes: S
-    };
-  }
-  const g = t.components?.securitySchemes ?? {};
-  for (const [a, i] of Object.entries(s)) {
-    const u = h(g[a]);
-    l(u) && p(u, i);
-  }
+  const s = S().getAuth(t);
+  r.auth.load({ [t]: s });
 };
-function M(e) {
+function E(t) {
   try {
-    return JSON.parse(e);
+    return JSON.parse(t);
   } catch {
     return;
   }
 }
-function N(e) {
+function b(t) {
   try {
-    if (e.startsWith("/") || e.startsWith("http://localhost"))
-      return e;
-    const c = new URLSearchParams({ scalar_url: e });
-    return new URL(`https://proxy.scalar.com/?${c}`).toString();
+    if (t.startsWith("/") || t.startsWith("http://localhost"))
+      return t;
+    const r = new URLSearchParams({ scalar_url: t });
+    return new URL(`https://proxy.scalar.com/?${r}`).toString();
   } catch {
-    return console.error(`Invalid URL provided: ${e}`), e;
+    return console.error(`Invalid URL provided: ${t}`), t;
   }
 }
 export {
-  f as authStorage,
-  C as createDocumentSettings,
-  P as getOperations,
-  N as makeScalarProxyUrl,
-  H as restoreAuthSecretsFromStorage,
-  M as safeParseJson
+  S as authStorage,
+  x as createDocumentSettings,
+  U as getOperations,
+  b as makeScalarProxyUrl,
+  A as restoreAuthSecretsFromStorage,
+  E as safeParseJson
 };

package/dist/hooks/use-chat-approvals.d.ts

@@ -1,24 +1,31 @@
-export declare function useChatApprovals(): {
-    approvalRequestedParts: import("vue").ComputedRef<({
+import type { ToolUIPart, UIMessagePart } from 'ai';
+import { type Tools } from '../state/state.js';
+type RequestToolPart = ToolUIPart & {
+    type: 'tool-execute-request';
+    state: 'input-available';
+    input: Tools['execute-request']['input'];
+};
+export declare function requestPartRequiresApproval(part: UIMessagePart<any, Tools>): part is RequestToolPart;
+export declare function useRequestApprovals(): {
+    approvalRequiredParts: import("vue").ComputedRef<({
         type: `tool-${string}`;
     } & {
         toolCallId: string;
         title?: string;
         providerExecuted?: boolean;
     } & {
-        state: "approval-requested";
+        state: "input-available";
         input: unknown;
         output?: never;
         errorText?: never;
         callProviderMetadata?: import("ai").ProviderMetadata;
-        approval: {
-            id: string;
-            approved?: never;
-            reason?: never;
-        };
+        approval?: never;
     } & {
-        state: "approval-requested";
+        type: "tool-execute-request";
+        state: "input-available";
+        input: Tools["execute-request"]["input"];
     })[]>;
-    respondToToolCalls: (approved: boolean) => Promise<void>;
+    respondToRequestApprovals: (approved: boolean) => Promise<void>;
 };
+export {};
 //# sourceMappingURL=use-chat-approvals.d.ts.map

package/dist/hooks/use-chat-approvals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-chat-approvals.d.ts","sourceRoot":"","sources":["../../src/hooks/use-chat-approvals.ts"],"names":[],"mappings":"AAWA,wBAAgB,gBAAgB;;;;;;;;;;;;;;;oBAuB648C,CAAC;kBAAuB,CAAC;;;eA7B/48C,oBAAoB;;mCAgB7B,OAAO;EAYpD"}
+{"version":3,"file":"use-chat-approvals.d.ts","sourceRoot":"","sources":["../../src/hooks/use-chat-approvals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,IAAI,CAAA;AAMnD,OAAO,EAAE,KAAK,KAAK,EAAY,MAAM,eAAe,CAAA;AAEpD,KAAK,eAAe,GAAG,UAAU,GAAG;IAClC,IAAI,EAAE,sBAAsB,CAAA;IAC5B,KAAK,EAAE,iBAAiB,CAAA;IACxB,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,CAAA;CACzC,CAAA;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,IAAI,eAAe,CAMpG;AAED,wBAAgB,mBAAmB;;;;;;;;;;;;;;;cAb3B,sBAAsB;eACrB,iBAAiB;eACjB,KAAK,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC;;0CAqBW,OAAO;EAuB3D"}

package/dist/hooks/use-chat-approvals.js

@@ -1,21 +1,34 @@
 import { computed as l } from "vue";
-import { useState as n } from "../state/state.js";
-function e(t) {
-  return t.type.startsWith("tool") && t.state === "approval-requested";
+import { executeRequestTool as i } from "../client-tools/execute-request.js";
+import { createDocumentSettings as n } from "../helpers.js";
+import { useState as m } from "../state/state.js";
+import { EXECUTE_CLIENT_SIDE_REQUEST_TOOL_NAME as s } from "../entities/tools/execute-request.js";
+function a(t) {
+  return t.type === `tool-${s}` && t.state === "input-available" && t.input?.method?.toLowerCase() !== "get";
 }
-function c() {
-  const t = n(), a = l(() => t.chat.messages.filter((o) => o.parts.some(e)).flatMap((o) => o.parts).filter(e));
-  async function s(o) {
-    const r = a.value.map(
-      (p) => t.chat.addToolApprovalResponse({
-        id: p.approval.id,
-        approved: o
-      })
-    );
-    await Promise.all(r);
+function h() {
+  const t = m(), r = l(() => t.chat.messages.filter((e) => e.parts.some(a)).flatMap((e) => e.parts).filter(a));
+  async function u(e) {
+    const p = r.value.map(async (o) => {
+      if (!e)
+        return await t.chat.addToolOutput({
+          tool: s,
+          toolCallId: o.toolCallId,
+          state: "output-error",
+          errorText: "The user denied the request."
+        });
+      await i({
+        documentSettings: n(t.workspaceStore),
+        input: o.input,
+        toolCallId: o.toolCallId,
+        chat: t.chat
+      });
+    });
+    await Promise.all(p);
   }
-  return { approvalRequestedParts: a, respondToToolCalls: s };
+  return { approvalRequiredParts: r, respondToRequestApprovals: u };
 }
 export {
-  c as useChatApprovals
+  a as requestPartRequiresApproval,
+  h as useRequestApprovals
 };

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

@@ -9,6 +9,7 @@ export declare function useSearch(): {
         logoUrl: string | null;
         slug: string;
         removable?: boolean | undefined;
+        searchEnabled?: boolean | undefined;
     }[], ApiMetadata[] | {
         id: string;
         title: string;
@@ -17,6 +18,7 @@ export declare function useSearch(): {
         logoUrl: string | null;
         slug: string;
         removable?: boolean | undefined;
+        searchEnabled?: 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":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAG/D,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;EAiCxB"}
+{"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"}