@salsita-ai/contracts 0.0.0-stage → 0.49.0-develop.2a2e8d75e7

package/dist/assistant/deployment-assistant.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+/** AI providers a deployment's assistant can run on. */
+export declare const ASSISTANT_AI_PROVIDERS: readonly ['openai'];
+/**
+ * Provider-neutral model tiers of the assistant manifest, most capable first. The server maps a tier
+ * to a concrete model of the chosen provider, so retiring a model never needs a project redeploy.
+ */
+export declare const ASSISTANT_MODEL_TIERS: readonly ['frontier', 'advanced', 'balanced', 'fast'];
+/** Reasoning levels of the assistant manifest; every tier's model accepts all of them. */
+export declare const ASSISTANT_REASONING_LEVELS: readonly ['low', 'medium', 'high'];
+export type AssistantAiProvider = (typeof ASSISTANT_AI_PROVIDERS)[number];
+export type AssistantModelTier = (typeof ASSISTANT_MODEL_TIERS)[number];
+export type AssistantReasoningLevel = (typeof ASSISTANT_REASONING_LEVELS)[number];
+/**
+ * The `ai` block of the assistant manifest: which provider, model tier and reasoning level the
+ * deployment's assistant runs with. Authored in the application spec, sent when a deployment is
+ * prepared and stored with it; the server has no defaults for any of the three.
+ */
+export interface AssistantAiSettings {
+    readonly provider: AssistantAiProvider;
+    readonly model: AssistantModelTier;
+    readonly reasoning: AssistantReasoningLevel;
+}
+export declare const AssistantAiSettings: z.ZodObject<{
+    provider: z.ZodEnum<["openai"]>;
+    model: z.ZodEnum<["frontier", "advanced", "balanced", "fast"]>;
+    reasoning: z.ZodEnum<["low", "medium", "high"]>;
+}, "strict", z.ZodTypeAny, {
+    provider: "openai";
+    model: "advanced" | "balanced" | "fast" | "frontier";
+    reasoning: "high" | "low" | "medium";
+}, {
+    provider: "openai";
+    model: "advanced" | "balanced" | "fast" | "frontier";
+    reasoning: "high" | "low" | "medium";
+}>;
+/**
+ * What a deployment registers for its assistant: the GraphQL SDL generated from the manifest, the
+ * prompt the SDK generates for its own version, the integrator's instructions and the AI settings.
+ * The server stores it with the deployment and builds every run's system prompt from it; a
+ * deployment that registers none has no assistant.
+ */
+export interface DeploymentAssistant {
+    readonly sdl: string;
+    readonly prompt: string;
+    readonly instructions?: string;
+    readonly ai: AssistantAiSettings;
+}
+export declare const DeploymentAssistant: z.ZodObject<{
+    sdl: z.ZodString;
+    prompt: z.ZodString;
+    instructions: z.ZodOptional<z.ZodString>;
+    ai: z.ZodObject<{
+        provider: z.ZodEnum<["openai"]>;
+        model: z.ZodEnum<["frontier", "advanced", "balanced", "fast"]>;
+        reasoning: z.ZodEnum<["low", "medium", "high"]>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "openai";
+        model: "advanced" | "balanced" | "fast" | "frontier";
+        reasoning: "high" | "low" | "medium";
+    }, {
+        provider: "openai";
+        model: "advanced" | "balanced" | "fast" | "frontier";
+        reasoning: "high" | "low" | "medium";
+    }>;
+}, "strict", z.ZodTypeAny, {
+    sdl: string;
+    prompt: string;
+    instructions?: string | undefined;
+    ai: {
+        provider: "openai";
+        model: "advanced" | "balanced" | "fast" | "frontier";
+        reasoning: "high" | "low" | "medium";
+    };
+}, {
+    sdl: string;
+    prompt: string;
+    instructions?: string | undefined;
+    ai: {
+        provider: "openai";
+        model: "advanced" | "balanced" | "fast" | "frontier";
+        reasoning: "high" | "low" | "medium";
+    };
+}>;

package/dist/assistant/deployment-assistant.js

@@ -0,0 +1 @@
+import{z as t}from"zod";export const ASSISTANT_AI_PROVIDERS=["openai"];export const ASSISTANT_MODEL_TIERS=["frontier","advanced","balanced","fast"];export const ASSISTANT_REASONING_LEVELS=["low","medium","high"];export const AssistantAiSettings=t.object({provider:t.enum(ASSISTANT_AI_PROVIDERS),model:t.enum(ASSISTANT_MODEL_TIERS),reasoning:t.enum(ASSISTANT_REASONING_LEVELS)}).strict();export const DeploymentAssistant=t.object({sdl:t.string().min(1),prompt:t.string().min(1),instructions:t.string().min(1).optional(),ai:AssistantAiSettings}).strict();

package/dist/assistant/graphql-tools.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+/** One single-operation GraphQL document of a `query` or `apply` tool call, with its own variables. */
+export interface AssistantGraphQLOperation {
+    /** The GraphQL document. It holds exactly one operation, a query or a mutation. */
+    readonly query: string;
+    readonly variables?: Readonly<Record<string, unknown>> | null;
+    readonly operationName?: string | null;
+}
+/**
+ * Input of the assistant's `query` and `apply` tools: the operations the browser runs in order
+ * against the configurator's GraphQL schema, each one seeing the changes of the ones before it.
+ */
+export interface AssistantGraphQLToolInput {
+    readonly operations: ReadonlyArray<AssistantGraphQLOperation>;
+}
+/**
+ * Parses a tool call's input in the browser, because a plain JSON Schema gives the client tool no
+ * typed input. Optional members also accept `null`, which a model may send for a value it leaves
+ * out; the tools are not sent as strict schemas, because `variables` is a free-form map.
+ */
+export declare const AssistantGraphQLToolInput: z.ZodObject<{
+    operations: z.ZodArray<z.ZodObject<{
+        query: z.ZodString;
+        variables: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        operationName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        variables?: Record<string, unknown> | null | undefined;
+        operationName?: string | null | undefined;
+    }, {
+        query: string;
+        variables?: Record<string, unknown> | null | undefined;
+        operationName?: string | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    operations: {
+        query: string;
+        variables?: Record<string, unknown> | null | undefined;
+        operationName?: string | null | undefined;
+    }[];
+}, {
+    operations: {
+        query: string;
+        variables?: Record<string, unknown> | null | undefined;
+        operationName?: string | null | undefined;
+    }[];
+}>;
+/**
+ * Client-side tool of the assistant chat that reads the configuration: the browser runs the
+ * operations against the configurator's GraphQL schema from the committed state and discards every
+ * change, so mutations in the list answer "what if" questions. The result is the list of standard
+ * GraphQL results with `committed: false`.
+ *
+ * The server passes the definition to the model without an implementation, so every call becomes a
+ * client-tool interrupt; the SDK registers the browser implementation via `.client()`.
+ */
+export declare const queryTool: import("@tanstack/ai").ToolDefinition<{
+    type: string;
+    properties: {
+        operations: {
+            type: string;
+            minItems: number;
+            description: string;
+            items: {
+                type: string;
+                properties: {
+                    query: {
+                        type: string;
+                        description: string;
+                    };
+                    variables: {
+                        type: string;
+                        description: string;
+                    };
+                    operationName: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+    };
+    required: string[];
+}, undefined, "query", false, undefined>;
+/**
+ * Client-side tool of the assistant chat that changes the configuration: the browser runs the same
+ * kind of list as {@link queryTool} and commits its changes as one undo step when every operation
+ * succeeds. It is registered for every session; in a session that may not change the configuration
+ * the browser refuses the call without running anything.
+ */
+export declare const applyTool: import("@tanstack/ai").ToolDefinition<{
+    type: string;
+    properties: {
+        operations: {
+            type: string;
+            minItems: number;
+            description: string;
+            items: {
+                type: string;
+                properties: {
+                    query: {
+                        type: string;
+                        description: string;
+                    };
+                    variables: {
+                        type: string;
+                        description: string;
+                    };
+                    operationName: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+    };
+    required: string[];
+}, undefined, "apply", false, undefined>;

package/dist/assistant/graphql-tools.js

@@ -0,0 +1 @@
+import{toolDefinition as e}from"@tanstack/ai";import{z as t}from"zod";export const AssistantGraphQLToolInput=t.object({operations:t.array(t.object({query:t.string(),variables:t.record(t.unknown()).nullish(),operationName:t.string().nullish()})).min(1)});let o={type:"object",properties:{operations:{type:"array",minItems:1,description:"The operations to run, in order. Each one sees the changes of the ones before it.",items:{type:"object",properties:{query:{type:"string",description:"A GraphQL document with exactly one operation, a query or a mutation."},variables:{type:"object",description:"Values of the variables the document declares. Prefer literals written into the document."},operationName:{type:"string",description:"The name of the operation, when the document names it."}},required:["query"]}}},required:["operations"]};export const queryTool=e({name:"query",description:"Runs GraphQL operations against the open configuration and returns their results. Nothing is changed: mutations in the list are applied to a temporary copy that is discarded after the call, which shows what a change would do.",inputSchema:o});export const applyTool=e({name:"apply",description:"Runs GraphQL operations against the open configuration and keeps their changes as one undo step. All or nothing: when any operation fails, nothing is changed. The result says whether the changes were committed.",inputSchema:o});

package/dist/assistant/index.d.ts

@@ -0,0 +1,6 @@
+export { browserDetailsTool } from './browser-details-tool.js';
+export { ASSISTANT_AI_PROVIDERS, ASSISTANT_MODEL_TIERS, ASSISTANT_REASONING_LEVELS, AssistantAiSettings, DeploymentAssistant, } from './deployment-assistant.js';
+export { AssistantGraphQLToolInput, applyTool, queryTool } from './graphql-tools.js';
+export type { AssistantGraphQLOperation } from './graphql-tools.js';
+export type { AssistantAiProvider, AssistantModelTier, AssistantReasoningLevel } from './deployment-assistant.js';
+export { AssistantMessageMetadata } from './message-metadata.js';

package/dist/assistant/index.js

@@ -0,0 +1 @@
+export{browserDetailsTool}from"./browser-details-tool.js";export{ASSISTANT_AI_PROVIDERS,ASSISTANT_MODEL_TIERS,ASSISTANT_REASONING_LEVELS,AssistantAiSettings,DeploymentAssistant}from"./deployment-assistant.js";export{AssistantGraphQLToolInput,applyTool,queryTool}from"./graphql-tools.js";export{AssistantMessageMetadata}from"./message-metadata.js";

package/dist/assistant/message-metadata.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * Metadata the assistant chat client attaches to each user message (AG-UI message `metadata`). It is
+ * persisted with the message, and the server shows `sentAt` to the model next to the message so the
+ * model knows when each message was written — the seed of the per-turn history diff.
+ */
+export interface AssistantMessageMetadata {
+    /** Client send time of the user message, as an ISO 8601 timestamp with offset. */
+    readonly sentAt: string;
+}
+export declare const AssistantMessageMetadata: z.ZodObject<{
+    sentAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sentAt: string;
+}, {
+    sentAt: string;
+}>;

package/dist/assistant/message-metadata.js

@@ -0,0 +1 @@
+import{z as t}from"zod";export const AssistantMessageMetadata=t.object({sentAt:t.string().datetime({offset:!0})});

package/dist/chat/api.d.ts

@@ -0,0 +1,52 @@
+import type OpenAI from 'openai';
+import type { Uploadable } from 'openai/core/uploads';
+/**
+ * Generate a completion from a prompt and message history
+ * @param openai OpenAI instance
+ * @param params completion options
+ * @param prompt base prompt
+ * @param messages message history- last message should be user message
+ * @param tools available functions to call
+ * @returns
+ */
+export declare const createCompletion: (openai: OpenAI, params: Omit<OpenAI.Chat.Completions.ChatCompletionCreateParams, 'stream' | 'messages'>, prompt: string, messages: OpenAI.ChatCompletionMessageParam[], tools?: OpenAI.ChatCompletionTool[]) => Promise<import("openai/core/streaming.mjs").Stream<OpenAI.ChatCompletionChunk> & {
+    _request_id?: string | null;
+}>;
+/**
+ * Generate a text transcription from an audio file
+ * @param openai OpenAI instance
+ * @param params transcription options
+ * @param file audio file
+ * @returns
+ */
+export declare const createTranscription: (openai: OpenAI, params: Omit<OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming, 'file' | 'model'>, file: Uploadable) => Promise<OpenAI.Audio.Transcription & {
+    _request_id?: string | null;
+}>;
+/**
+ * Generate a speech audio file from a text message
+ * @param openai OpenAI instance
+ * @param params speech options
+ * @param message text message
+ * @returns
+ */
+export declare const createSpeech: (openai: OpenAI, params: Omit<OpenAI.Audio.Speech.SpeechCreateParams, 'input' | 'model' | 'voice'>, message: string) => Promise<Response>;
+/**
+ * Generate a function call completion from a prompt and message
+ * @param openai OpenAI instance
+ * @param params completion options
+ * @param prompt base prompt
+ * @param message input message
+ * @param tools available functions to call
+ * @returns
+ */
+export declare const createFunctionCallCompletion: (openai: OpenAI, params: Omit<OpenAI.Chat.Completions.ChatCompletionCreateParams, 'stream' | 'messages'>, prompt: string, message: string, tools: OpenAI.ChatCompletionTool[]) => Promise<OpenAI.ChatCompletionMessageFunctionToolCall.Function[]>;
+/**
+ * Generate an embedding from a text input
+ * @param openai OpenAI instance
+ * @param params embedding options
+ * @param input text input
+ * @returns
+ */
+export declare const createEmbedding: (openai: OpenAI, params: Omit<OpenAI.EmbeddingCreateParams, 'model' | 'input'> & {
+    model?: OpenAI.EmbeddingCreateParams['model'];
+}, input: string) => Promise<number[] | undefined>;

package/dist/chat/api.js

@@ -0,0 +1 @@
+export const createCompletion=async(e,t,o,c,n)=>e.chat.completions.create({...t,messages:[{role:"system",content:o},...c],...n&&n.length>0?{tools:n,tool_choice:"auto"}:{},stream:!0});export const createTranscription=async(e,t,o)=>e.audio.transcriptions.create({...t,model:"whisper-1",file:o});export const createSpeech=async(e,t,o)=>e.audio.speech.create({...t,input:o,model:"tts-1",voice:"alloy"});export const createFunctionCallCompletion=async(e,t,o,c,n)=>{let a=await e.chat.completions.create({...t,messages:[{role:"system",content:o},{role:"user",content:c}],...n.length>0?{tools:n,tool_choice:1===n.length?n[0]:"auto"}:{}});return a.choices[0]?.message.tool_calls?.filter(e=>"function"===e.type).map(e=>e.function)??[]};export const createEmbedding=async(e,t,o)=>{let c=await e.embeddings.create({model:"text-embedding-3-small",...t,input:o});return c.data[0]?.embedding};

package/dist/chat/completions/messages.d.ts

@@ -0,0 +1,3 @@
+import type OpenAI from 'openai';
+export declare const createAssistantMessage: (content?: string, toolCalls?: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[]) => OpenAI.ChatCompletionAssistantMessageParam;
+export declare const createToolCallResultMessage: (content: string, toolCallId: string) => OpenAI.Chat.Completions.ChatCompletionToolMessageParam;

package/dist/chat/completions/messages.js

@@ -0,0 +1 @@
+export const createAssistantMessage=(t,o)=>({role:"assistant",...t?{content:t}:void 0,...o?{tool_calls:o.filter(t=>"function"===t.type).map(t=>({id:t.id,function:t.function,type:"function"}))}:void 0});export const createToolCallResultMessage=(t,o)=>({role:"tool",content:t,tool_call_id:o});

package/dist/chat/completions/types.d.ts

@@ -0,0 +1,28 @@
+import type OpenAI from 'openai';
+export declare const ChunkType: {
+    readonly content: 'content';
+    readonly calls: 'calls';
+    readonly error: 'error';
+    readonly augment: 'augment';
+};
+export interface ChatMessageContentChunk {
+    type: typeof ChunkType.content;
+    content: string;
+}
+export interface ChatToolCalls {
+    type: typeof ChunkType.calls;
+    tool_calls: OpenAI.Chat.Completions.ChatCompletionMessageFunctionToolCall[];
+}
+export interface ChatErrorChunk {
+    type: typeof ChunkType.error;
+    error: string;
+}
+export interface ChatMessageAugmentation {
+    type: typeof ChunkType.augment;
+    augmentation: Record<string, unknown>;
+}
+export type ChatStreamChunk = ChatMessageContentChunk | ChatToolCalls | ChatErrorChunk | ChatMessageAugmentation;
+export declare const isChatMessageContentChunk: (chunk: ChatStreamChunk) => chunk is ChatMessageContentChunk;
+export declare const isChatMessageAugmentation: (chunk: ChatStreamChunk) => chunk is ChatMessageAugmentation;
+export declare const isChatToolCalls: (chunk: ChatStreamChunk) => chunk is ChatToolCalls;
+export declare const isChatError: (chunk: ChatStreamChunk) => chunk is ChatErrorChunk;

package/dist/chat/completions/types.js

@@ -0,0 +1 @@
+export const ChunkType={content:"content",calls:"calls",error:"error",augment:"augment"};export const isChatMessageContentChunk=t=>t.type===ChunkType.content;export const isChatMessageAugmentation=t=>t.type===ChunkType.augment;export const isChatToolCalls=t=>t.type===ChunkType.calls;export const isChatError=t=>t.type===ChunkType.error;

package/dist/chat/functions/augmentations.d.ts

@@ -0,0 +1,3 @@
+import type { Empty } from '../utils/types.js';
+import { type ChatFunction } from './types.js';
+export declare const simpleAugmentationHandler: <P>(key: keyof P) => ChatFunction<Empty, Empty, P>;

package/dist/chat/functions/augmentations.js

@@ -0,0 +1 @@
+export const simpleAugmentationHandler=t=>e=>({result:e[t]?JSON.stringify(e):""});

package/dist/chat/functions/create.d.ts

@@ -0,0 +1,5 @@
+import type { JSONSchemaType } from 'ajv';
+import type { Empty } from '../utils/types.js';
+import type { ChatExecutableFunction, ChatFunction, ChatFunctionDefinition } from './types.js';
+export declare const createChatExecutableFunction: <C extends Empty = Empty, R extends Empty = Empty, P = undefined>(name: string, parameters: JSONSchemaType<P> | undefined, func: ChatFunction<C, R, P>) => ChatExecutableFunction<C, R, P>;
+export declare const createChatFunctionDefinition: <C extends Empty = Empty, R extends Empty = Empty, P = undefined>(name: string, description: string, parameters: JSONSchemaType<P> | undefined, func: ChatFunction<C, R, P>) => ChatFunctionDefinition<C, R, P>;

package/dist/chat/functions/create.js

@@ -0,0 +1 @@
+import{createValidator as t}from"./validate.js";export const createChatExecutableFunction=(e,a,n)=>({name:e,function:n,validate:t(a)});export const createChatFunctionDefinition=(t,e,a,n)=>({description:e,parameters:a,...createChatExecutableFunction(t,a,n)});

package/dist/chat/functions/process.d.ts

@@ -0,0 +1,14 @@
+import type OpenAI from 'openai';
+import type { Empty } from '../utils/types.js';
+import type { ChatExecutableFunction, ChatFunctionDefinition, ChatFunctionResult } from './types.js';
+export declare const createCompletionTool: <C extends Empty = Empty, R extends Empty = Empty>({ name, description, parameters, }: OpenAI.FunctionDefinition | ChatFunctionDefinition<C, R, any>) => OpenAI.ChatCompletionFunctionTool;
+/**
+ * Processes tool calls and generates array of return messages.
+ *
+ * @param toolCalls - array of tool calls from assistant message
+ * @param functions - array of available functions
+ * @param context - context object to pass to functions
+ * @param resultProcessor - optional function used to process each function call result
+ * @returns return messages
+ */
+export declare const processToolCalls: <C extends Empty = Empty, R extends Empty = Empty>(toolCalls: OpenAI.ChatCompletionMessageToolCall[], functions: Array<ChatExecutableFunction<C, R, any>>, context: C, resultProcessor?: (result: ChatFunctionResult<R>, call: OpenAI.ChatCompletionMessageToolCall) => void) => Promise<OpenAI.ChatCompletionToolMessageParam[]>;

package/dist/chat/functions/process.js

@@ -0,0 +1 @@
+export const createCompletionTool=({name:t,description:n,parameters:o})=>({type:"function",function:{name:t,description:n,parameters:o}});export const processToolCalls=async(t,n,o,e)=>{let l=[];for(let r of t){let{id:t}=r,c={tool_call_id:t,role:"tool"};if("function"!==r.type){l.push({...c,content:`Tool call type '${r.type}' is not supported — only function tool calls can be processed by this handler.`});continue}let{function:i}=r;try{let t=n?.find(t=>t.name===i.name);if(!t){l.push({...c,content:`Function \`${i.name}\` not found`});continue}let s=JSON.parse(i.arguments??"{}"),a=t.validate(s);if(a){l.push({...c,content:a});continue}let u=await t.function(s,o);e?.(u,r),l.push({...c,content:u.result})}catch(o){let n=o instanceof Error?o.message:String(o);throw Error(`Call ${t} of function \`${i.name}\` resulted in error: ${n}`)}}return l};

package/dist/chat/functions/types.d.ts

@@ -0,0 +1,21 @@
+import type OpenAI from 'openai';
+import type { Empty } from '../utils/types.js';
+export type ChatFunctionResult<R extends Empty = Empty> = {
+    result: string;
+} & R;
+export type ChatFunction<C extends Empty = Empty, R extends Empty = Empty, P = undefined> = (arg: P, context: C) => ChatFunctionResult<R> | Promise<ChatFunctionResult<R>>;
+export interface ChatExecutableFunction<C extends Empty = Empty, R extends Empty = Empty, P = undefined> {
+    name: string;
+    function: ChatFunction<C, R, P>;
+    validate: (data: unknown) => string | undefined;
+}
+/**
+ * Function call definition and implementation
+ */
+export interface ChatFunctionDefinition<C extends Empty = Empty, R extends Empty = Empty, P = undefined> extends OpenAI.FunctionDefinition, ChatExecutableFunction<C, R, P> {
+}
+export interface ChatDocument {
+    name: string;
+    description: string;
+    content: string;
+}

package/dist/chat/functions/types.js

@@ -0,0 +1 @@
+export{};

package/dist/chat/functions/validate.d.ts

@@ -0,0 +1 @@
+export declare const createValidator: <P extends Record<string, unknown>>(parameters?: P) => (data: unknown) => string | undefined;

package/dist/chat/functions/validate.js

@@ -0,0 +1,2 @@
+import{Ajv as e}from"ajv";let r=new e({allErrors:!0});export const createValidator=e=>{let t=r.compile(e??{type:"object",properties:{},required:[]});return e=>{if(!t(e)){let e;return(e=t.errors)&&e.length>0?`Invalid arguments:
+${e.map(e=>`- ${e.instancePath?`${e.instancePath}: `:""}${e.message}`).join("\n  ")}`:"Invalid arguments."}}};

package/dist/chat/index.d.ts

@@ -0,0 +1,10 @@
+export { createCompletion, createFunctionCallCompletion, createTranscription as createSpeechToTextCompletion, createSpeech as createTextToSpeechCompletion, createEmbedding, } from './api.js';
+export { createAssistantMessage, createToolCallResultMessage } from './completions/messages.js';
+export { ChunkType, isChatMessageContentChunk, isChatMessageAugmentation, isChatToolCalls, isChatError, } from './completions/types.js';
+export type { ChatMessageContentChunk, ChatToolCalls, ChatErrorChunk, ChatStreamChunk, ChatMessageAugmentation, } from './completions/types.js';
+export { createValidator } from './functions/validate.js';
+export { createChatFunctionDefinition as createFunctionDefintion, createChatExecutableFunction, } from './functions/create.js';
+export { simpleAugmentationHandler } from './functions/augmentations.js';
+export { processToolCalls, createCompletionTool } from './functions/process.js';
+export type { ChatFunction, ChatExecutableFunction, ChatFunctionDefinition, ChatFunctionResult, } from './functions/types.js';
+export type { Empty } from './utils/types.js';

package/dist/chat/index.js

@@ -0,0 +1 @@
+export{createCompletion,createFunctionCallCompletion,createTranscription as createSpeechToTextCompletion,createSpeech as createTextToSpeechCompletion,createEmbedding}from"./api.js";export{createAssistantMessage,createToolCallResultMessage}from"./completions/messages.js";export{ChunkType,isChatMessageContentChunk,isChatMessageAugmentation,isChatToolCalls,isChatError}from"./completions/types.js";export{createValidator}from"./functions/validate.js";export{createChatFunctionDefinition as createFunctionDefintion,createChatExecutableFunction}from"./functions/create.js";export{simpleAugmentationHandler}from"./functions/augmentations.js";export{processToolCalls,createCompletionTool}from"./functions/process.js";

package/dist/chat/utils/types.d.ts

@@ -0,0 +1 @@
+export type Empty = Record<string, unknown>;

package/dist/chat/utils/types.js

@@ -0,0 +1 @@
+export{};

package/dist/clerk/clerk-backend-api-client.d.ts

@@ -0,0 +1,129 @@
+import type { Logger } from '@salsita-ai/common/utils';
+import { type UserInvite, type UserUpdate } from './clerk-backend-api-types.js';
+export declare class ClerkBackendApiClient {
+    private readonly _clerkApiKey;
+    private readonly _context;
+    constructor(_clerkApiKey: string, _context: {
+        logger: Omit<Logger, 'appendToGlobalContext' | 'verbose'>;
+    });
+    private _fetchClerkApi;
+    private _createError;
+    banUser(userId: string): Promise<{
+        id: string;
+        emailAddress: string;
+        fullName: string | null;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        status: import("./clerk-backend-api-types.js").ClerkUserStatus;
+        createdAt: number;
+        lastSignInAt: number | null;
+    }>;
+    deleteUser(userId: string): Promise<{
+        deleted: boolean;
+    }>;
+    fetchInvitations(params: {
+        limit: number;
+        offset: number;
+        query?: string;
+    }): Promise<{
+        id: string;
+        emailAddress: string;
+        status: import("./clerk-backend-api-types.js").ClerkInvitationStatus;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        expiresAt: number;
+        createdAt: number;
+        updatedAt: number;
+    }[]>;
+    fetchOrgs(): Promise<{
+        total_count: number;
+        data: {
+            id: string;
+            name: string;
+            userTags: {
+                id: string;
+                label: string;
+            }[];
+        }[];
+    }>;
+    fetchOrgOrThrow(): Promise<{
+        id: string;
+        name: string;
+        userTags: {
+            id: string;
+            label: string;
+        }[];
+    }>;
+    fetchUser(userId: string): Promise<{
+        id: string;
+        emailAddress: string;
+        fullName: string | null;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        status: import("./clerk-backend-api-types.js").ClerkUserStatus;
+        createdAt: number;
+        lastSignInAt: number | null;
+    }>;
+    fetchUsers(params: {
+        limit: number;
+        offset: number;
+        query?: string;
+    }): Promise<{
+        id: string;
+        emailAddress: string;
+        fullName: string | null;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        status: import("./clerk-backend-api-types.js").ClerkUserStatus;
+        createdAt: number;
+        lastSignInAt: number | null;
+    }[]>;
+    inviteUser(invite: UserInvite): Promise<{
+        id: string;
+        emailAddress: string;
+        status: import("./clerk-backend-api-types.js").ClerkInvitationStatus;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        expiresAt: number;
+        createdAt: number;
+        updatedAt: number;
+    }>;
+    verifyOAuthUser(oauthProviderBaseUrl: string, accessToken: string): Promise<{
+        id: string;
+    }>;
+    refreshToken(oauthProviderBaseUrl: string, clientId: string, clientSecret: string, refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        expirationTime: number;
+    }>;
+    revokeInvitation(invitationId: string): Promise<{
+        id: string;
+        emailAddress: string;
+        status: import("./clerk-backend-api-types.js").ClerkInvitationStatus;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        expiresAt: number;
+        createdAt: number;
+        updatedAt: number;
+    }>;
+    unbanUser(userId: string): Promise<{
+        id: string;
+        emailAddress: string;
+        fullName: string | null;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        status: import("./clerk-backend-api-types.js").ClerkUserStatus;
+        createdAt: number;
+        lastSignInAt: number | null;
+    }>;
+    updateUser(invite: UserUpdate): Promise<{
+        id: string;
+        emailAddress: string;
+        fullName: string | null;
+        role: import("./clerk-backend-api-types.js").ClerkRole;
+        tags: string[];
+        status: import("./clerk-backend-api-types.js").ClerkUserStatus;
+        createdAt: number;
+        lastSignInAt: number | null;
+    }>;
+}

package/dist/clerk/clerk-backend-api-client.js

@@ -0,0 +1 @@
+import{ClerkError as e,ClerkErrorResponse as r,Invitation as t,InvitationsResponse as a,OAuthRefreshTokenResult as n,OAuthUserInfo as s,OrganizationsResponse as i,User as o,UserDelete as c,UserResponse as h}from"./clerk-backend-api-types.js";let l=(e,r)=>{let t=new URL(e,"https://api.clerk.com");if(void 0!==r)for(let[e,a]of Object.entries(r))t.searchParams.append(e,String(a));return t};export class ClerkBackendApiClient{_clerkApiKey;_context;constructor(e,r){this._clerkApiKey=e,this._context=r}async _fetchClerkApi(e,r,t,a){let n=await fetch(r,{method:e,headers:{Authorization:`Bearer ${this._clerkApiKey}`,...a?{"Content-Type":"application/json"}:{}},body:a}),s=await n.json();try{return t.parse(s)}catch(e){throw this._createError(e,s)}}_createError(t,a){try{let t=r.parse(a),n="errors"in t?t.errors[0]:t;if(n)return new e(n)}catch{}return this._context.logger.error("Failed to parse Clerk error response:",{response:a}),Error("Unknown Clerk error",{cause:t})}banUser(e){return this._fetchClerkApi("POST",l(`/v1/users/${e}/ban`),o)}deleteUser(e){return this._fetchClerkApi("DELETE",l(`/v1/users/${e}`),c)}async fetchInvitations(e){let{limit:r,offset:t,query:n=""}=e,s=l("/v1/invitations",{limit:r,offset:t,orderBy:"created_at",...n.length>0?{query:n}:null});return await this._fetchClerkApi("GET",s,a)}async fetchOrgs(){return this._fetchClerkApi("GET",l("/v1/organizations"),i)}async fetchOrgOrThrow(){let e=await this.fetchOrgs();if(e.total_count>1)throw Error("Clerk: fetchOrgOrThrow expects exactly one organization, found more");let r=e.data[0];if(!r)throw Error("Clerk: fetchOrgOrThrow expects exactly one organization, found none");return r}async fetchUser(e){return this._fetchClerkApi("GET",l(`/v1/users/${e}`),o)}async fetchUsers(e){let{limit:r,offset:t,query:a=""}=e,n=l("/v1/users",{limit:r,offset:t,orderBy:"-created_at",...a.length>0?{query:a}:null});return await this._fetchClerkApi("GET",n,h)}async inviteUser(e){let r=l("/v1/invitations");return this._fetchClerkApi("POST",r,t,JSON.stringify({email_address:e.emailAddress,public_metadata:{role:e.role,tags:e.tags},ignore_existing:!0}))}async verifyOAuthUser(e,r){let t=null;try{let a=new URL("/oauth/userinfo",e),n=await fetch(a,{method:"GET",headers:{Authorization:`Bearer ${r}`,"Content-Type":"application/json"}});return t=await n.json(),{id:s.parse(t).user_id}}catch(e){throw this._createError(e,t)}}async refreshToken(e,r,t,a){let s=null;try{let i=new URL("/oauth/token",e),o=await fetch(i,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:new URLSearchParams({grant_type:"refresh_token",refresh_token:a,client_id:r,client_secret:t})});s=await o.json();let c=n.parse(s);return{accessToken:c.access_token,refreshToken:c.refresh_token,expirationTime:Date.now()/1e3+c.expires_in}}catch(e){throw this._createError(e,s)}}async revokeInvitation(e){return this._fetchClerkApi("POST",l(`/v1/invitations/${e}/revoke`),t)}async unbanUser(e){return this._fetchClerkApi("POST",l(`/v1/users/${e}/unban`),o)}async updateUser(e){let r=null;try{let t=l(`/v1/users/${e.id}`),a=await fetch(t,{method:"PATCH",headers:{Authorization:`Bearer ${this._clerkApiKey}`,"Content-Type":"application/json"},body:JSON.stringify({private_metadata:{role:e.role,tags:e.tags}})});if(200!==a.status)throw Error(`Failed to update user ${e.id}: ${a.statusText}`);return r=await a.json(),o.parse(r)}catch(e){throw this._createError(e,r)}}}