@aimount/core 0.1.0 → 0.2.0-beta.1

package/dist/runtime-api.d.ts

@@ -1,88 +1,448 @@
-import { RuntimeRunEventStream, RuntimeStreamRunEventsParams, RuntimeTelemetryEvent } from './events';
-import { MessageFeedback } from './feedback';
-import { Session, SessionPage, SessionStar } from './session';
-import { RuntimeGetSessionMessagesParams, RuntimeMessagePage, RuntimeRespondUserMessage, RuntimeSetMessageFeedbackParams } from './messages';
-import { RuntimeConfiguration, RuntimeRemainingLimits } from './profile';
-import { RuntimeCreateSessionParams, RuntimeGetSessionsParams } from './sessions';
-import { RuntimeResult } from './shared';
-import { RuntimeToolClaim, RuntimeToolClaimRequest, RuntimeToolClaimRenewParams, RuntimeToolOutputCommitRequest } from './tools';
-export type RuntimeRunStatus = 'queued' | 'running' | 'waiting_tool_outputs' | 'ready_to_continue' | 'continued' | 'completed' | 'interrupted' | 'failed' | 'cancelled';
-export type RuntimeCreateResponseParams = {
-    sessionId: string;
-    toolsKey: string;
+import { RuntimeResult } from './shared.js';
+export type RuntimeError = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+};
+export type RuntimeSelectionOption = {
+    id: string;
+    name: string;
+    modalities?: RuntimeModelModalities | undefined;
+};
+export type RuntimeModelInputModality = 'text' | 'image' | 'pdf' | (string & {});
+export type RuntimeModelOutputModality = 'text' | (string & {});
+export type RuntimeModelModalities = {
+    input: RuntimeModelInputModality[];
+    output: RuntimeModelOutputModality[];
+};
+export type RuntimeLimits = {
+    maxInputTextLength: number;
+    maxMessages: number | null;
+    maxTokens: number | null;
+    messagesPerMinute: number | null;
+    messagesPerHour: number | null;
+    messagesPerDay: number | null;
+};
+export type RuntimeProfile = {
+    scope: RuntimeProfileScope;
+    selection: {
+        roles: RuntimeSelectionOption[];
+        models: RuntimeSelectionOption[];
+        defaults: RuntimeSelection | null;
+    };
+    limits: RuntimeLimits;
+};
+type RuntimeSessionOwnership = {
+    agentId: string;
+    userId: string;
+};
+type RuntimeProfileScope = RuntimeSessionOwnership & {
+    profileId: string;
+};
+export type RuntimeSession = {
+    id: string;
     agentId: string;
+    userId: string;
+    title: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type RuntimeSessionSummary = {
+    id: string;
+    agentId: string;
+    userId: string;
+    title: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastActivityAt: string;
+};
+export type RuntimeSessionExecutionStatus = 'idle' | 'requested' | 'running' | 'waiting_tools' | 'stopping' | (string & {});
+export type RuntimeSessionExecution = {
+    sessionId: string;
+    executionToken: string;
+    status: RuntimeSessionExecutionStatus;
+    inputBoundary?: RuntimeInputBoundary | null;
+    agentMessageId?: string | null;
+    selection?: RuntimeSelection | undefined;
+    createdAt: string;
+    updatedAt: string;
+};
+export type RuntimeTextContent = {
+    type: 'text';
+    id: string;
+    text: string;
+};
+export type RuntimeFileContent = {
+    type: 'file';
+    id: string;
+    fileId: string;
+    name?: string | undefined;
+    mediaType?: string | undefined;
+    sizeBytes?: number | undefined;
+};
+export type RuntimeToolCallContent = {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    status: 'succeeded';
+    input: Record<string, unknown>;
+    result: unknown;
+} | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    status: 'failed';
+    input: Record<string, unknown>;
+    error: RuntimeError;
+} | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    status: 'denied';
+    input: Record<string, unknown>;
+    denial: RuntimeError;
+} | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    status: 'cancelled';
+    input: Record<string, unknown>;
+    cancellation: RuntimeError;
+};
+export type RuntimeUnknownContent = {
+    type: 'unknown';
+    id: string;
+    originalType: string;
+    payload: unknown;
+};
+export type RuntimeContent = RuntimeTextContent | RuntimeFileContent | RuntimeToolCallContent | RuntimeUnknownContent;
+export type RuntimeUserMessageContent = RuntimeContent;
+export type RuntimeAgentMessageContent = RuntimeContent;
+export type RuntimeSelection = {
+    roleId: string;
     modelId: string;
+};
+export type RuntimeInputBoundary = {
+    lastUserMessageId: string;
+};
+export type RuntimeSubmitInputContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'file';
+    fileId: string;
+};
+export type RuntimeSessionItemBase<TType extends string> = {
+    type: TType;
+    id: string;
+    sessionId: string;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeUserMessage = RuntimeSessionItemBase<'user_message'> & {
+    commandId?: string;
+    content: RuntimeUserMessageContent[];
+    environment?: unknown;
+    selection?: RuntimeSelection;
+};
+export type RuntimePendingUserMessage = {
+    id: string;
+    commandId: string;
+    content: RuntimeSubmitInputContent[];
+    selection?: RuntimeSelection;
+    createdAt: string;
+};
+export type RuntimeAgentMessageStatus = 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export type RuntimeAgentMessage = RuntimeSessionItemBase<'agent_message'> & {
+    status: RuntimeAgentMessageStatus;
+    inputBoundary?: RuntimeInputBoundary | undefined;
+    selection?: RuntimeSelection;
+    content: RuntimeAgentMessageContent[];
+};
+export type RuntimeCompactionStatus = 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export type RuntimeCompaction = RuntimeSessionItemBase<'compaction'> & {
+    status: RuntimeCompactionStatus;
+    reason?: string | undefined;
+    beforeItemId?: string | undefined;
+    summary?: string | undefined;
+    retainedContext?: string | undefined;
+    error?: RuntimeError | undefined;
+    cancellation?: RuntimeError | undefined;
+};
+export type RuntimeUnknownSessionItem = RuntimeSessionItemBase<'unknown'> & {
+    originalType: string;
+    payload: unknown;
+};
+export type RuntimeSessionItem = RuntimeUserMessage | RuntimeAgentMessage | RuntimeCompaction | RuntimeUnknownSessionItem;
+export type RuntimeEventType = 'session.created' | 'pending_input.created' | 'pending_input.committed' | 'session_item.created' | 'session_item.part.created' | 'session_item.content_delta' | 'session_item.updated' | 'session_execution.updated';
+export type RuntimeSessionItemEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    commandId?: string | undefined;
+    type: 'session_item.created' | 'session_item.updated';
+    createdAt: string;
+    payload: {
+        item: RuntimeSessionItem;
+    };
+};
+export type RuntimePendingInputCreatedEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    commandId?: string | undefined;
+    type: 'pending_input.created';
+    createdAt: string;
+    payload: {
+        pendingInput: {
+            id: string;
+            sessionId: string;
+            commandId: string;
+            content: RuntimeSubmitInputContent[];
+            requestedSelection?: Partial<RuntimeSelection> | undefined;
+            selection?: RuntimeSelection | undefined;
+            createdAt: string;
+        };
+    };
+};
+export type RuntimePendingInputCommittedEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    commandId?: string | undefined;
+    type: 'pending_input.committed';
+    createdAt: string;
+    payload: {
+        pendingInputId: string;
+        commandId: string;
+        itemId: string;
+    };
+};
+export type RuntimeSessionExecutionEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    type: 'session_execution.updated';
+    createdAt: string;
+    payload: {
+        execution: RuntimeSessionExecution;
+    };
+};
+export type RuntimeSessionItemContentDeltaEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    type: 'session_item.content_delta';
+    createdAt: string;
+    payload: {
+        itemId: string;
+        partId: string;
+        partType: 'text';
+        delta: string;
+    };
+};
+export type RuntimeSessionItemPartCreatedEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    type: 'session_item.part.created';
+    createdAt: string;
+    payload: {
+        itemId: string;
+        part: RuntimeTextContent & {
+            id: string;
+        };
+    };
+};
+export type RuntimeSessionCreatedEventWire = {
+    eventId: string;
+    previousEventId: null;
+    sessionId: string;
+    type: 'session.created';
+    createdAt: string;
+    payload: {
+        session: RuntimeSession;
+        execution: RuntimeSessionExecution;
+    };
+};
+export type RuntimeUnknownEventWire = {
+    eventId: string;
+    previousEventId: string | null;
+    sessionId: string;
+    type: 'unknown';
+    originalType: string;
+    createdAt: string;
+    payload: Record<string, unknown>;
+};
+export type RuntimeEventWire = RuntimeSessionCreatedEventWire | RuntimePendingInputCreatedEventWire | RuntimePendingInputCommittedEventWire | RuntimeSessionItemEventWire | RuntimeSessionItemPartCreatedEventWire | RuntimeSessionItemContentDeltaEventWire | RuntimeSessionExecutionEventWire | RuntimeUnknownEventWire;
+export type RuntimeCommandAck = {
+    commandId: string;
+    status: 'accepted';
+};
+export type RuntimeInputCommandAck = RuntimeCommandAck;
+export type RuntimeStopCommandAck = RuntimeCommandAck;
+export type RuntimeCreateFileUploadParams = {
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+    signal?: AbortSignal;
+};
+export type RuntimeCreateFileUploadResult = {
+    fileId: string;
+    status: 'draft';
+    uploadUrl: string;
+    uploadUrlExpiresAt: string;
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+};
+export type RuntimeRefreshFileUploadUrlParams = {
+    fileId: string;
+    signal?: AbortSignal;
+};
+export type RuntimeRefreshFileUploadUrlResult = {
+    fileId: string;
+    uploadUrl: string;
+    uploadUrlExpiresAt: string;
+};
+export type RuntimeCompleteFileUploadParams = {
+    fileId: string;
+    signal?: AbortSignal;
+};
+export type RuntimeCompleteFileUploadResult = {
+    fileId: string;
+    status: 'ready';
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+};
+export type RuntimeCreateFileAccessUrlParams = {
+    fileId: string;
+    signal?: AbortSignal;
+};
+export type RuntimeCreateFileAccessUrlResult = {
+    url: string;
+    expiresAt: string;
+};
+export type RuntimeCreateSessionParams = {
     idempotencyKey: string;
-    message: RuntimeRespondUserMessage;
-    context?: string;
-    tools?: Record<string, unknown>;
+    title?: string;
     signal?: AbortSignal;
 };
-export type RuntimeCreateResponseResult = {
-    responseId: string;
+export type RuntimeGetSessionViewParams = {
     sessionId: string;
-    userMessageId: string;
-    runId: string;
+    itemsLimit?: number;
+    itemsCursor?: string;
+    signal?: AbortSignal;
 };
-export type RuntimeContinueRunParams = {
-    responseId: string;
-    runId: string;
-    idempotencyKey: string;
+export type RuntimeListSessionsParams = {
+    limit?: number;
+    cursor?: string;
     signal?: AbortSignal;
 };
-export type RuntimeContinueRunResult = {
-    responseId: string;
-    runId: string;
-    status: Extract<RuntimeRunStatus, 'queued'>;
+export type RuntimeDeleteSessionParams = {
+    sessionId: string;
+    signal?: AbortSignal;
 };
-export type RuntimeGetSessionMessageRunParams = {
+export type RuntimeReadSessionEventsParams = {
     sessionId: string;
-    assistantMessageId: string;
+    afterEventId?: string;
+    limit?: number;
+    waitMs?: number;
     signal?: AbortSignal;
 };
-export type RuntimeMessageRun = {
-    responseId: string;
-    runId: string;
-    status: RuntimeRunStatus;
-    reason: string | null;
+export type RuntimeSubmitSessionInputParams = {
+    sessionId: string;
+    idempotencyKey: string;
+    content: RuntimeSubmitInputContent[];
+    selection?: RuntimeSelection;
+    signal?: AbortSignal;
 };
-export type RuntimeCancelRunParams = {
-    responseId: string;
-    runId: string;
-    reason?: 'user.cancelled' | 'client.unsync';
+export type RuntimeStopSessionExecutionParams = {
+    sessionId: string;
+    idempotencyKey: string;
+    executionToken: string;
     signal?: AbortSignal;
 };
-export type RuntimeCancelRunResult = {
-    responseId: string;
-    runId: string;
-    status: Extract<RuntimeRunStatus, 'cancelled'>;
+export type RuntimeCreateSessionResult = {
+    session: RuntimeSession;
+    execution: RuntimeSessionExecution;
+    lastEventId: string;
+    capabilities: RuntimeSessionView['capabilities'];
+    items: RuntimeSessionView['items'];
+    pendingInput: RuntimeSessionView['pendingInput'];
+    ack: {
+        sessionId: string;
+        commandId: string;
+        status: 'accepted';
+    };
 };
-export type RuntimeCommitToolOutputsParams = {
-    responseId: string;
-    runId: string;
-    toolOutputs: RuntimeToolOutputCommitRequest[];
-    signal?: AbortSignal;
+type RuntimeCommandCapability<TReason extends string> = {
+    available: true;
+} | {
+    available: false;
+    reason: TReason;
+};
+export type RuntimeSessionView = {
+    session: RuntimeSession;
+    execution: RuntimeSessionExecution;
+    lastEventId: string | null;
+    capabilities: {
+        sendText: RuntimeCommandCapability<'session_unavailable' | 'maintenance'>;
+        stop: RuntimeCommandCapability<'execution_not_active' | 'session_unavailable' | 'maintenance'>;
+    };
+    items: {
+        entries: RuntimeSessionItem[];
+        continuityToken: string;
+        olderCursor: string | null;
+        newerCursor: string | null;
+        hasOlder: boolean;
+        hasNewer: boolean;
+    };
+    pendingInput: {
+        entries: RuntimePendingUserMessage[];
+    };
+};
+export type RuntimeListSessionsResult = {
+    items: RuntimeSessionSummary[];
+    nextCursor: string | null;
+};
+export type RuntimeSessionEventsPage = {
+    events: RuntimeEventWire[];
+    nextEventId: string | null;
 };
 export type RuntimeApi = {
-    getConfiguration: () => Promise<RuntimeResult<RuntimeConfiguration>>;
-    getRemainingLimits: () => Promise<RuntimeResult<RuntimeRemainingLimits>>;
-    getSessions: (_?: RuntimeGetSessionsParams) => Promise<RuntimeResult<SessionPage>>;
-    createSession: (_?: RuntimeCreateSessionParams) => Promise<RuntimeResult<Session>>;
-    getSession: (_: string) => Promise<RuntimeResult<Session>>;
-    deleteSession: (_: string) => Promise<RuntimeResult<void>>;
-    setSessionStar: (_: {
-        sessionId: string;
-        starred: boolean;
-    }) => Promise<RuntimeResult<SessionStar>>;
-    getSessionMessages: (_: RuntimeGetSessionMessagesParams) => Promise<RuntimeResult<RuntimeMessagePage>>;
-    setMessageFeedback: (_: RuntimeSetMessageFeedbackParams) => Promise<RuntimeResult<MessageFeedback>>;
-    recordTelemetryEvents: (_: RuntimeTelemetryEvent[]) => Promise<RuntimeResult<void>>;
-    createResponse: (_: RuntimeCreateResponseParams) => Promise<RuntimeResult<RuntimeCreateResponseResult>>;
-    getSessionMessageRun: (_: RuntimeGetSessionMessageRunParams) => Promise<RuntimeResult<RuntimeMessageRun | null>>;
-    continueRun: (_: RuntimeContinueRunParams) => Promise<RuntimeResult<RuntimeContinueRunResult>>;
-    cancelRun: (_: RuntimeCancelRunParams) => Promise<RuntimeResult<RuntimeCancelRunResult>>;
-    streamRunEvents: (_: RuntimeStreamRunEventsParams) => Promise<RuntimeResult<RuntimeRunEventStream>>;
-    claimToolCall: (_: RuntimeToolClaimRequest) => Promise<RuntimeResult<RuntimeToolClaim>>;
-    renewToolClaim: (_: RuntimeToolClaimRenewParams) => Promise<RuntimeResult<RuntimeToolClaim>>;
-    commitToolOutputs: (_: RuntimeCommitToolOutputsParams) => Promise<RuntimeResult<void>>;
+    getProfile: (_?: {
+        signal?: AbortSignal;
+    }) => Promise<RuntimeResult<RuntimeProfile>>;
+    createFileUpload: (_: RuntimeCreateFileUploadParams) => Promise<RuntimeResult<RuntimeCreateFileUploadResult>>;
+    refreshFileUploadUrl: (_: RuntimeRefreshFileUploadUrlParams) => Promise<RuntimeResult<RuntimeRefreshFileUploadUrlResult>>;
+    completeFileUpload: (_: RuntimeCompleteFileUploadParams) => Promise<RuntimeResult<RuntimeCompleteFileUploadResult>>;
+    createFileAccessUrl: (_: RuntimeCreateFileAccessUrlParams) => Promise<RuntimeResult<RuntimeCreateFileAccessUrlResult>>;
+    createSession: (_: RuntimeCreateSessionParams) => Promise<RuntimeResult<RuntimeCreateSessionResult>>;
+    listSessions: (_?: RuntimeListSessionsParams) => Promise<RuntimeResult<RuntimeListSessionsResult>>;
+    deleteSession: (_: RuntimeDeleteSessionParams) => Promise<RuntimeResult<void>>;
+    getSessionView: (_: RuntimeGetSessionViewParams) => Promise<RuntimeResult<RuntimeSessionView>>;
+    readSessionEvents: (_: RuntimeReadSessionEventsParams) => Promise<RuntimeResult<RuntimeSessionEventsPage>>;
+    submitSessionInput: (_: RuntimeSubmitSessionInputParams) => Promise<RuntimeResult<RuntimeInputCommandAck>>;
+    stopSessionExecution: (_: RuntimeStopSessionExecutionParams) => Promise<RuntimeResult<RuntimeStopCommandAck>>;
 };
+export declare function parseRuntimeError(input: unknown): RuntimeError;
+export declare function parseRuntimeProfile(input: unknown): RuntimeProfile;
+export declare function parseRuntimeSession(input: unknown): RuntimeSession;
+export declare function parseRuntimeSessionExecution(input: unknown): RuntimeSessionExecution;
+export declare function parseRuntimeContent(input: unknown, contentIndex?: number): RuntimeContent;
+export declare function parseRuntimeSessionItem(input: unknown): RuntimeSessionItem;
+export declare function parseRuntimeEventWire(input: unknown): RuntimeEventWire;
+export declare function parseRuntimeSessionEventsPage(input: unknown): RuntimeSessionEventsPage;
+export declare function parseRuntimeCommandAck(input: unknown): RuntimeCommandAck;
+export declare function parseRuntimeInputCommandAck(input: unknown): RuntimeInputCommandAck;
+export declare function parseRuntimeStopCommandAck(input: unknown): RuntimeStopCommandAck;
+export declare function parseRuntimeFileUploadResult(input: unknown): RuntimeCreateFileUploadResult;
+export declare function parseRuntimeFileUploadUrlResult(input: unknown): RuntimeRefreshFileUploadUrlResult;
+export declare function parseRuntimeFileCompleteResult(input: unknown): RuntimeCompleteFileUploadResult;
+export declare function parseRuntimeFileAccessUrlResult(input: unknown): RuntimeCreateFileAccessUrlResult;
+export declare function parseRuntimeCreateSessionResult(input: unknown): RuntimeCreateSessionResult;
+export declare function parseRuntimeSessionView(input: unknown): RuntimeSessionView;
+export declare function parseRuntimeListSessionsResult(input: unknown): RuntimeListSessionsResult;
+export {};

package/dist/shared.d.ts

@@ -1 +1 @@
-export type RuntimeResult<T, E extends Error = Error> = readonly [T, null] | readonly [null, E];
+export type RuntimeResult<T, E = Error> = readonly [T, null] | readonly [null, E];

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@aimount/core",
   "private": false,
-  "version": "0.1.0",
+  "version": "0.2.0-beta.1",
   "type": "module",
-  "description": "Core runtime contracts, tool authoring primitives, and message DTOs for aimount",
+  "description": "Core Runtime API contracts and DTOs for aimount",
   "publishConfig": {
     "access": "public"
   },
@@ -27,7 +27,6 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "ai": "6",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/dist/assistant-parts.d.ts

@@ -1,7 +0,0 @@
-import { MessageKnownPart, MessagePartUnknown } from './part';
-import { MessageStatus } from './status';
-export type { MessagePartFile as RuntimeAssistantFilePart, MessagePartReasoning as RuntimeAssistantReasoningPart, MessageProviderMetadata as RuntimeAssistantProviderMetadata, MessagePartSourceDocument as RuntimeAssistantSourceDocumentPart, MessagePartSourceUrl as RuntimeAssistantSourceUrlPart, MessagePartText as RuntimeAssistantTextPart, MessageToolApproval as RuntimeAssistantToolApproval, MessagePartTool as RuntimeAssistantToolPart, MessagePartUnknown as RuntimeAssistantUnknownPart, } from './part';
-export type RuntimeAssistantToolPartState = 'streaming' | 'call' | 'done' | 'error' | 'canceled';
-export type RuntimeAssistantPart = MessageKnownPart | MessagePartUnknown;
-export declare function collectPendingToolCallIdsFromAssistantParts(parts: ReadonlyArray<RuntimeAssistantPart>): string[];
-export declare function toDefaultStatusFromAssistantParts(parts: ReadonlyArray<RuntimeAssistantPart>): MessageStatus;

package/dist/events.d.ts

@@ -1,127 +0,0 @@
-import { RuntimeMessageStatus } from './messages';
-export type RuntimeTelemetryEvent = {
-    type: 'chat.rendered.v1' | 'chat.focus_changed.v1' | 'chat.session_selected.v1' | 'chat.prompt_edit_started.v1' | 'chat.prompt_submitted.v1' | 'chat.response_started.v1' | 'chat.response_finished.v1' | 'chat.response_stopped.v1' | 'chat.feedback_set.v1' | 'chat.tool_call_started.v1' | 'chat.tool_call_finished.v1';
-    occurredAt: Date;
-    sessionId?: string | undefined;
-    messageId?: string | undefined;
-    payload: Record<string, unknown>;
-};
-export type RuntimeMessageStreamFinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other';
-export type RuntimeEvent = {
-    v: 1;
-    type: 'message.created';
-    messageId: string;
-    sessionId: string;
-    role: 'assistant';
-    status: RuntimeMessageStatus;
-} | {
-    v: 1;
-    type: 'message.checkpoint.created';
-    messageId: string;
-    checkpointId: string;
-} | {
-    v: 1;
-    type: 'message.revision.rebased';
-    messageId: string;
-    checkpointId: string;
-    revisionId: string;
-} | {
-    v: 1;
-    type: 'part.text.start';
-    partId: string;
-} | {
-    v: 1;
-    type: 'part.text.delta';
-    partId: string;
-    delta: string;
-} | {
-    v: 1;
-    type: 'part.text.end';
-    partId: string;
-} | {
-    v: 1;
-    type: 'part.reasoning.start';
-    partId: string;
-} | {
-    v: 1;
-    type: 'part.reasoning.delta';
-    partId: string;
-    delta: string;
-} | {
-    v: 1;
-    type: 'part.reasoning.end';
-    partId: string;
-} | {
-    v: 1;
-    type: 'part.source-url';
-    sourceId: string;
-    url: string;
-    title?: string;
-} | {
-    v: 1;
-    type: 'part.source-document';
-    sourceId: string;
-    mediaType: string;
-    title: string;
-    filename?: string;
-} | {
-    v: 1;
-    type: 'part.file';
-    url: string;
-    mediaType: string;
-    filename?: string;
-} | {
-    v: 1;
-    type: 'part.tool.input.start';
-    toolCallId: string;
-    name: string;
-} | {
-    v: 1;
-    type: 'part.tool.input.delta';
-    toolCallId: string;
-    delta: string;
-} | {
-    v: 1;
-    type: 'part.tool.call';
-    toolCallId: string;
-    name: string;
-    input: unknown;
-} | {
-    v: 1;
-    type: 'part.tool.result';
-    toolCallId: string;
-    output: unknown;
-    preliminary?: boolean;
-} | {
-    v: 1;
-    type: 'part.tool.error';
-    toolCallId: string;
-    error: string;
-} | {
-    v: 1;
-    type: 'part.tool.denied';
-    toolCallId: string;
-} | {
-    v: 1;
-    type: 'part.unknown';
-    rawType: string;
-    reason: 'unsupported_chunk' | 'invalid_chunk';
-    payload?: unknown;
-} | {
-    v: 1;
-    type: 'message.status';
-    messageId: string;
-    status: RuntimeMessageStatus;
-    pendingToolCallIds?: string[];
-};
-export type RuntimeRunEvent = {
-    seq: number;
-    event: RuntimeEvent;
-};
-export type RuntimeRunEventStream = AsyncIterable<RuntimeRunEvent>;
-export type RuntimeStreamRunEventsParams = {
-    responseId: string;
-    runId: string;
-    afterSeq: number;
-    signal?: AbortSignal;
-};

package/dist/feedback.d.ts

@@ -1,8 +0,0 @@
-export type MessageFeedbackType = 'like' | 'dislike';
-export type MessageFeedback = {
-    sessionId: string;
-    messageId: string;
-    feedbackType: MessageFeedbackType;
-    reason: string | null;
-    updatedAt: Date;
-};

package/dist/message-data.d.ts

@@ -1 +0,0 @@
-export type { Message as MessageData } from './message';