@iyio/convo-lang

import { ReadonlySubject } from "@iyio/common"; import { Observable } from "rxjs"; import { ZodType, ZodTypeAny, z } from "zod"; import { ConvoExecutionContext } from "./ConvoExecutionContext"; import { AppendConvoMessageObjOptions, CloneConversationOptions, ConvoAppend, ConvoCapability, ConvoCompletion, ConvoCompletionOptions, ConvoCompletionService, ConvoDefItem, ConvoFunction, ConvoFunctionDef, ConvoImportHandler, ConvoMessage, ConvoMessageAndOptStatement, ConvoMessagePart, ConvoMessagePrefixOptions, ConvoParsingResult, ConvoPrintFunction, ConvoRagCallback, ConvoScopeFunction, ConvoSubTask, ConvoTokenUsage, ConvoTypeDef, ConvoVarDef, FlatConvoConversation, FlattenConvoOptions } from "./convo-types"; export interface ConversationOptions { userRoles?: string[]; roleMap?: Record<string, string>; completionService?: ConvoCompletionService; serviceCapabilities?: ConvoCapability[]; capabilities?: ConvoCapability[]; disableMessageCapabilities?: boolean; maxAutoCompleteDepth?: number; /** * If true time tags will be added to appended user message */ trackTime?: boolean; /** * If true tokenUsage tags will be added to completed messages */ trackTokens?: boolean; /** * If true model tags will be added to completed messages */ trackModel?: boolean; /** * If true the conversation will not automatically be flattened when new message are appended. */ disableAutoFlatten?: boolean; /** * Number of milliseconds to delay before flattening the conversation. The delay is used to * debounce appends. */ autoFlattenDelayMs?: number; /** * A function that will be used to output debug values. By default debug information is written * to the output of the conversation as comments */ debug?: (...values: any[]) => void; debugMode?: boolean; /** * If true all text based messages will be parsed as markdown and the lines of the markdown will * be used to set vars. */ setMarkdownVars?: boolean; /** * If true all text based message will be parsed as markdown */ parseMarkdown?: boolean; /** * A callback used to implement rag retrieval. */ ragCallback?: ConvoRagCallback; /** * An initial convo script to append to the Conversation */ initConvo?: string; /** * Called at the end of the Conversation constructor */ onConstructed?: (convo: Conversation) => void; defaultVars?: Record<string, any>; /** * Array of ConvoDefItems to define */ define?: ConvoDefItem[]; importHandler?: ConvoImportHandler; } export declare class Conversation { private _convo; get convo(): string; getConvoStrings(): string[]; private _messages; get messages(): ConvoMessage[]; private readonly _onAppend; get onAppend(): Observable<ConvoAppend>; private readonly _activeTaskCount; get activeTaskCountSubject(): ReadonlySubject<number>; get activeTaskCount(): number; private readonly _trackTime; get trackTimeSubject(): ReadonlySubject<boolean>; get trackTime(): boolean; set trackTime(value: boolean); private readonly _trackTokens; get trackTokensSubject(): ReadonlySubject<boolean>; get trackTokens(): boolean; set trackTokens(value: boolean); private readonly _trackModel; get trackModelSubject(): ReadonlySubject<boolean>; get trackModel(): boolean; set trackModel(value: boolean); private readonly _debugMode; get debugModeSubject(): ReadonlySubject<boolean>; get debugMode(): boolean; set debugMode(value: boolean); private readonly _flat; get flatSubject(): ReadonlySubject<FlatConvoConversation | null>; /** * A reference to the last flattening of the conversation */ get flat(): FlatConvoConversation | null; private readonly _subTasks; get subTasksSubject(): ReadonlySubject<ConvoSubTask[]>; get subTasks(): ConvoSubTask[]; private readonly _beforeAppend; get beforeAppend(): Observable<ConvoAppend>; /** * Unregistered variables will be available during execution but will not be added to the code * of the conversation. For example the __cwd var is often used to set the current working * directory but is not added to the conversation code. */ readonly unregisteredVars: Record<string, any>; userRoles: string[]; roleMap: Record<string, string>; private completionService?; maxAutoCompleteDepth: number; readonly externFunctions: Record<string, ConvoScopeFunction>; /** * The default capabilities of the conversation. Additional capabilities can be enabled by * the first and last message of the conversation as long a disableMessageCapabilities is not * true. */ readonly capabilities: ConvoCapability[]; /** * If true capabilities enabled by message in the conversation will be ignored. */ readonly disableMessageCapabilities: boolean; /** * Capabilities that should be enabled by the underlying completion service. */ readonly serviceCapabilities: ConvoCapability[]; private readonly disableAutoFlatten; private readonly autoFlattenDelayMs; dynamicFunctionCallback: ConvoScopeFunction | undefined; /** * A callback used to implement rag retrieval. */ private readonly ragCallback?; /** * A function that will be used to output debug values. By default debug information is written * to the output of the conversation as comments */ debug?: (...values: any[]) => void; print: ConvoPrintFunction; private readonly defaultOptions; readonly defaultVars: Record<string, any>; constructor(options?: ConversationOptions); private getMessageListCapabilities; /** * Gets the capabilities enabled by the given tags. If disableMessageCapabilities is true * undefined is always returned */ private getMessageCapabilities; private _isDisposed; get isDisposed(): boolean; dispose(): void; private _defaultApiKey; setDefaultApiKey(key: string | null): void; getDefaultApiKey(): string | null; private parseCode; private readonly enabledCapabilities; enableCapability(cap: ConvoCapability): void; autoUpdateCompletionService(): void; createChild(options?: ConversationOptions): Conversation; /** * Creates a new Conversation and appends the messages of this conversation to the newly * created conversation. */ clone(options?: CloneConversationOptions): Conversation; /** * Creates a new Conversation and appends the system messages of this conversation to the newly * created conversation. */ cloneSystem(): Conversation; /** * Creates a new Conversation and appends the non-function messages of this conversation to the newly * created conversation. */ cloneWithNoFunctions(): Conversation; /** * Appends new messages to the conversation and by default does not add code to the conversation. */ appendMessageObject(message: ConvoMessage | ConvoMessage[], { disableAutoFlatten, appendCode }?: AppendConvoMessageObjOptions): void; private transformMessageBeforeAppend; append(messages: string | (ConvoMessagePart | string)[], mergeWithPrev?: boolean, throwOnError?: boolean): ConvoParsingResult; private autoFlattenId; private autoFlattenAsync; private autoFlatPromiseRef; private getAutoFlattenPromise; private setFlattenAsync; /** * Get the flattened version of this Conversation. * @param noCache If true the Conversation will not used the current cached version of the * flattening and will be re-flattened. */ getLastAutoFlatAsync(noCache?: boolean): Promise<FlatConvoConversation | undefined>; appendUserMessage(message: string, options?: ConvoMessagePrefixOptions): void; appendAssistantMessage(message: string, options?: ConvoMessagePrefixOptions): void; appendMessage(role: string, message: string, options?: ConvoMessagePrefixOptions): void; appendDefine(defineCode: string, description?: string): ConvoParsingResult; appendTopLevel(defineCode: string, description?: string): ConvoParsingResult; getVar(nameOrPath: string, defaultValue?: any): any; private getPrefixTags; private setFlat; callFunctionAsync(fn: ConvoFunction | string, args?: Record<string, any>, options?: ConvoCompletionOptions): Promise<any>; appendFunctionCall(functionName: string, args?: Record<string, any>): void; completeWithFunctionCallAsync(name: string, args?: Record<string, any>, options?: ConvoCompletionOptions): Promise<ConvoCompletion>; /** * Appends a user message then competes the conversation * @param append Optional message to append before submitting */ completeUserMessageAsync(userMessage: string): Promise<ConvoCompletion>; /** * Submits the current conversation and optionally appends messages to the conversation before * submitting. * @param append Optional message to append before submitting */ completeAsync(appendOrOptions?: string | ConvoCompletionOptions): Promise<ConvoCompletion>; /** * Completes the conversation and returns the last message as JSON. It is recommended using * `@json` mode with the last message that is appended. */ completeJsonAsync(appendOrOptions?: string | ConvoCompletionOptions): Promise<any>; /** * Completes the conversation and returns the last message as JSON. It is recommended using * `@json` mode with the last message that is appended. */ completeJsonSchemeAsync<Z extends ZodTypeAny = ZodType<any>, T = z.infer<Z>>(params: Z, userMessage: string): Promise<T | undefined>; /** * Completes the conversation and returns the last message call params. The last message of the * conversation should instruct the LLM to call a function. */ callStubFunctionAsync(appendOrOptions?: string | ConvoCompletionOptions): Promise<any>; private tryCompleteAsync; private readonly _isCompleting; get isCompletingSubject(): ReadonlySubject<boolean>; get isCompleting(): boolean; private _completeAsync; private writeTemplates; private startSubTasks; getReversedMappedRole(role: string | null | undefined): string; getMappedRole(role: string | null | undefined): string; createConvoExecutionContext(append?: string[]): ConvoExecutionContext; private flattenMsg; private importMessages; private loadImportsAsync; importAsync(name: string, index?: number): Promise<ConvoMessage[]>; flattenAsync(exe?: ConvoExecutionContext, { task, setCurrent, discardTemplates, threadFilter, }?: FlattenConvoOptions): Promise<FlatConvoConversation>; private applyRagMode; private getThreadFilter; private isTagConditionTrue; private applyTagsAndState; private applyResponseFormat; shouldDebug(exe?: ConvoExecutionContext): boolean; readonly debugToConversation: (...args: any[]) => void; private readonly definitionItems; define(items: ConvoDefItem | (ConvoDefItem[]), override?: boolean): ConvoParsingResult | undefined; defineType(type: ConvoTypeDef, override?: boolean): ConvoParsingResult | undefined; defineTypes(types: ConvoTypeDef[], override?: boolean): ConvoParsingResult | undefined; defineVar(variable: ConvoVarDef, override?: boolean): ConvoParsingResult | undefined; defineVars(vars: ConvoVarDef[], override?: boolean): ConvoParsingResult | undefined; defineFunction(fn: ConvoFunctionDef, override?: boolean): ConvoParsingResult | undefined; defineFunctions(fns: ConvoFunctionDef[], override?: boolean): ConvoParsingResult | undefined; defineLocalFunctions(funcs: Record<string, (...args: any[]) => any>): void; private createFunctionImpl; getAssignment(name: string, excludePreAssigned?: boolean): ConvoMessageAndOptStatement | undefined; private _getAssignment; private preAssignMessages; /** * Used to mark variables, types and function as assigned before actually appending the code. */ preAssign(convoCode: string): void; /** * Returns the sum of all token usage tags */ getTokenUsage(fromIndex?: number): ConvoTokenUsage; }