@getmodus/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,365 @@
+import { c as components, H as HttpClient, M as ModusConfig, P as Page, A as AgentType, V as VariationView, a as Agent, C as ContextItem, b as ContextItemLookupRow, d as CustomContextItemsResource, e as ConversationKind, f as ConversationListItem, g as Conversation, S as ScopeConversationsResource, h as Skill, i as ModusClientBase, j as ModusOptions } from './conversations-nx1ujbiv.cjs';
+export { k as ContextType, l as Message, O as OPERATIONS, m as OperationId, n as OperationSpec, o as SkillStatus, p as SkillVariation, q as conversationSkillId, r as operations, s as paths } from './conversations-nx1ujbiv.cjs';
+
+declare class ModusError extends Error {
+    readonly statusCode?: number;
+    readonly requestId?: string;
+    readonly responseHeaders?: Record<string, string>;
+    readonly body?: string;
+    readonly code?: string;
+    constructor(message: string, options?: {
+        statusCode?: number;
+        requestId?: string;
+        responseHeaders?: Record<string, string>;
+        body?: string;
+        code?: string;
+    });
+}
+declare class APIConnectionError extends ModusError {
+    constructor(message: string);
+}
+declare class AuthenticationError extends ModusError {
+    constructor(message: string, options?: ConstructorParameters<typeof ModusError>[1]);
+}
+declare class PermissionDeniedError extends ModusError {
+    constructor(message: string, options?: ConstructorParameters<typeof ModusError>[1]);
+}
+declare class NotFoundError extends ModusError {
+    constructor(message: string, options?: ConstructorParameters<typeof ModusError>[1]);
+}
+declare class ConflictError extends ModusError {
+    constructor(message: string, options?: ConstructorParameters<typeof ModusError>[1]);
+}
+declare class UnprocessableError extends ModusError {
+    readonly errors?: unknown;
+    constructor(message: string, options?: ConstructorParameters<typeof ModusError>[1] & {
+        errors?: unknown;
+    });
+}
+declare class RateLimitError extends ModusError {
+    readonly retryAfter?: number;
+    constructor(message: string, options?: ConstructorParameters<typeof ModusError>[1] & {
+        retryAfter?: number;
+    });
+}
+declare class InternalServerError extends ModusError {
+    constructor(message: string, statusCode: number, options?: ConstructorParameters<typeof ModusError>[1]);
+}
+declare class RunCancelledError extends ModusError {
+    constructor(message?: string);
+}
+declare class StreamTimeoutError extends ModusError {
+    constructor(message?: string);
+}
+declare class ValidationError extends ModusError {
+    constructor(message: string);
+}
+
+type ChatResult = components['schemas']['SkillChatResponseDto'];
+type ChatRequest = components['schemas']['SkillChatRequestDto'];
+type ChatModel = ChatRequest['model'];
+
+interface TokenEvent {
+    readonly type: 'token';
+    content: string;
+}
+interface DoneEvent {
+    readonly type: 'done';
+    runId: string;
+    threadId: string;
+}
+interface ErrorEvent {
+    readonly type: 'error';
+    message: string;
+}
+interface CancelledEvent {
+    readonly type: 'cancelled';
+}
+interface StreamTimeoutEvent {
+    readonly type: 'stream_timeout';
+}
+interface AssistantContentResetEvent {
+    readonly type: 'assistant_content_reset';
+    content: string;
+    visibleContent?: string;
+    attempt: number;
+    reason: 'provider_stream_failed';
+}
+type ActiveConversationRunStatus = 'queued' | 'pending' | 'running';
+interface ActiveConversationRun {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly status: ActiveConversationRunStatus;
+    readonly message?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+type RunEvent = TokenEvent | DoneEvent | ErrorEvent | CancelledEvent | StreamTimeoutEvent | AssistantContentResetEvent;
+
+declare class ChatStream {
+    private readonly http;
+    private readonly path;
+    private readonly body;
+    private final?;
+    private readonly textParts;
+    constructor(http: HttpClient, path: string, body: Record<string, unknown>);
+    textStream(): AsyncGenerator<string>;
+    eventStream(): AsyncGenerator<RunEvent>;
+    private events;
+    getFinalResult(): ChatResult;
+}
+
+type AgentRunListItem = components['schemas']['AutomationRunListItemDto'];
+type AgentRun = components['schemas']['GetAutomationRunResponseDto'];
+type AgentRunCreateRequest = components['schemas']['AgentRunDto'];
+type SkillRunCreateRequest = components['schemas']['SkillRunDto'];
+type ModusRunCreateRequest = components['schemas']['ModusRunDto'];
+type ResumeRunRequest = components['schemas']['ResumeRunDto'];
+type CreateAgentRunRequest = AgentRunCreateRequest;
+type CancelRunRequest = components['schemas']['CancelRunDto'];
+type InterruptRunRequest = components['schemas']['InterruptRunDto'];
+type EditQueuedRunRequest = components['schemas']['EditQueuedRunDto'];
+type WorkflowActionRequest = components['schemas']['WorkflowActionDto'];
+type RunStatus = 'running' | 'awaiting_human' | 'completed' | 'error' | 'cancelled' | 'all_executions' | (string & {});
+type RunTimeframe = 'last_hour' | 'last_day' | 'last_week' | (string & {});
+type ApprovalScope = 'mine' | 'all' | (string & {});
+
+interface AgentRunStream {
+    readonly runId: string;
+    readonly events: AsyncIterable<RunEvent>;
+}
+declare class WorkflowRunsResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    list(workflowId: number | string, options?: {
+        pageSize?: number;
+        pageToken?: string;
+        status?: RunStatus;
+        timeframe?: RunTimeframe;
+        approvalScope?: ApprovalScope;
+        search?: string;
+    }): Promise<Page<AgentRunListItem>>;
+    private listPage;
+    get(workflowId: number | string, runId: string, options?: {
+        temporalRunId?: string;
+    }): Promise<AgentRun>;
+    create(workflowId: number | string, body: CreateAgentRunRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<AgentRunStream>;
+    createScope(scopeId: number | string, body: SkillRunCreateRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<AgentRunStream>;
+    createModus(body: ModusRunCreateRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<AgentRunStream>;
+    resume(runId: string, body: ResumeRunRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<AgentRunStream>;
+    cancel(runId: string): Promise<void>;
+    events(runId: string): Promise<unknown>;
+    interrupt(runId: string): Promise<void>;
+    editQueued(runId: string): Promise<void>;
+    active(options?: {
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<Page<ActiveConversationRun>>;
+    private activePage;
+    activeBySession(sessionIds: readonly string[]): Promise<ActiveConversationRun[]>;
+    stream(runId: string, options?: {
+        lastEventId?: string;
+    }): AgentRunStream;
+    private createRun;
+    private parseEvents;
+}
+
+type Connection = components['schemas']['ConnectionDto'];
+
+/** One value entry from context item listValues (shape varies by context type). */
+type ContextValueRow = Record<string, unknown>;
+
+type SkillContextComposition = components['schemas']['ComposeSkillContextResponseDto'];
+type ModusContextComposition = components['schemas']['ModusContextResponseDto'];
+type ComposeSkillContextRequest = components['schemas']['ComposeSkillContextRequestDto'];
+type ModusContextRequest = components['schemas']['ModusContextRequestDto'];
+
+type SuggestionQuestion = components['schemas']['SuggestionQuestionDto'];
+type SuggestionEventType = components['schemas']['SuggestionEventType'];
+type SuggestionEventSource = components['schemas']['SuggestionEventSource'];
+type RecordSuggestionEventRequest = components['schemas']['RecordSuggestionEventDto'];
+
+declare class AgentWorkflowActionsResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    execute(body: WorkflowActionRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<AgentRunStream>;
+    cancel(runId: string): Promise<void>;
+    private parseEvents;
+}
+
+/** Read / invoke access to Modus workflows (`/api/v1/workflows`). */
+declare class WorkflowsResource {
+    private readonly http;
+    private readonly config;
+    readonly runs: WorkflowRunsResource;
+    readonly workflowActions: AgentWorkflowActionsResource;
+    constructor(http: HttpClient, config: ModusConfig);
+    list(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        search?: string;
+        type?: AgentType;
+        view?: VariationView;
+        includeVariation?: boolean;
+    }): Promise<Page<Agent>>;
+    private listPage;
+    get(workflowId: number | string, options?: {
+        view?: VariationView;
+        includeVariation?: boolean;
+    }): Promise<Agent>;
+}
+
+declare class ConnectionsResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    list(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        type?: string;
+    }): Promise<Page<Connection>>;
+    private listPage;
+    find(options: {
+        name: string;
+        type?: string;
+        pageSize?: number;
+    }): Promise<Connection | undefined>;
+}
+
+type JsonObjectInput = Record<string, unknown>;
+type ContentProjection = components['schemas']['ContentProjectionDto'];
+
+declare class ContextItemsResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    list(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        contextType?: string;
+    }): Promise<Page<ContextItem>>;
+    private listPage;
+    get(uid: string): Promise<ContextItem>;
+    lookup(options: {
+        contextType: string;
+        dataPath: string[];
+        contentProjection?: JsonObjectInput | ContentProjection;
+    }): Promise<ContextItemLookupRow | undefined>;
+    listValues(uid: string, contextType: string, contentKeyPath: string, options?: {
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<Page<ContextValueRow>>;
+    listValuesFor(item: ContextItem, contentKeyPath: string, options?: {
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<Page<ContextValueRow>>;
+    private listValuesPage;
+}
+
+/** Read access to the Modus knowledge base. */
+declare class ContextResource {
+    readonly items: ContextItemsResource;
+    readonly customItems: CustomContextItemsResource;
+    constructor(http: HttpClient, config: ModusConfig);
+}
+
+declare class ModusConversationsResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    list(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        kind?: ConversationKind;
+    }): Promise<Page<ConversationListItem>>;
+    private listPage;
+    get(threadId: string): Promise<Conversation>;
+}
+
+/** Org-wide Modus assistant. */
+declare class ModusResource {
+    private readonly http;
+    private readonly config;
+    readonly conversations: ModusConversationsResource;
+    constructor(http: HttpClient, config: ModusConfig);
+    getContext(message: string, options?: {
+        limit?: number;
+    }): Promise<ModusContextComposition>;
+    chat(message: string, options: {
+        model: ChatModel;
+        threadId?: string;
+    }): Promise<ChatResult>;
+    chatStream(message: string, options: {
+        model: ChatModel;
+        threadId?: string;
+    }): ChatStream;
+}
+
+/** Read / invoke access to Modus scopes (`/api/v1/scopes`). */
+declare class ScopesResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    conversations(scopeId: number | string): ScopeConversationsResource;
+    list(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        search?: string;
+        view?: VariationView;
+        managerId?: number;
+    }): Promise<Page<Skill>>;
+    private listPage;
+    get(scopeId: number | string, options?: {
+        view?: VariationView;
+    }): Promise<Skill>;
+    getContext(scopeId: number | string, message: string, options?: {
+        limit?: number;
+    }): Promise<SkillContextComposition>;
+    chat(scopeId: number | string, message: string, options: {
+        model: ChatModel;
+        threadId?: string;
+    }): Promise<ChatResult>;
+    chatStream(scopeId: number | string, message: string, options: {
+        model: ChatModel;
+        threadId?: string;
+    }): ChatStream;
+}
+
+declare class SuggestionsResource {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: ModusConfig);
+    list(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        skillId?: number;
+        skillIds?: readonly number[];
+    }): Promise<Page<SuggestionQuestion>>;
+    private listPage;
+    recordEvent(id: string, event: RecordSuggestionEventRequest): Promise<void>;
+}
+
+/** Read / invoke client for Modus scopes, workflows, connections, and more. */
+declare class Modus extends ModusClientBase {
+    readonly scopes: ScopesResource;
+    readonly modus: ModusResource;
+    readonly workflows: WorkflowsResource;
+    readonly context: ContextResource;
+    readonly connections: ConnectionsResource;
+    readonly suggestions: SuggestionsResource;
+    constructor(options?: ModusOptions);
+}
+
+export { APIConnectionError, Agent, type AgentRun, type AgentRunCreateRequest, type AgentRunListItem, type AgentRunStream, AgentType, type ApprovalScope, type AssistantContentResetEvent, AuthenticationError, type CancelRunRequest, type CancelledEvent, type ChatModel, type ChatRequest, type ChatResult, ChatStream, type ComposeSkillContextRequest, ConflictError, type Connection, ContextItem, ContextItemLookupRow, type ContextValueRow, Conversation, ConversationKind, ConversationListItem, type CreateAgentRunRequest, type DoneEvent, type EditQueuedRunRequest, type ErrorEvent, InternalServerError, type InterruptRunRequest, Modus, type ModusContextComposition, type ModusContextRequest, ModusError, ModusOptions, type ModusRunCreateRequest, NotFoundError, Page, PermissionDeniedError, RateLimitError, type RecordSuggestionEventRequest, type ResumeRunRequest, RunCancelledError, type RunEvent, type RunStatus, type RunTimeframe, Skill, type SkillContextComposition, type SkillRunCreateRequest, StreamTimeoutError, type StreamTimeoutEvent, type SuggestionEventSource, type SuggestionEventType, type SuggestionQuestion, type TokenEvent, UnprocessableError, ValidationError, VariationView, type WorkflowActionRequest, components };