@assistant-wi/core 0.0.1-alpha.7

package/README.md

@@ -0,0 +1,40 @@
+# @assistant-wi/core
+
+`@assistant-wi/core` is the foundational contract package for assistant-wi.
+
+## Role
+
+This package owns the extracted, framework-neutral contract layer that sits below
+runtime transports and interaction orchestration.
+
+## Owns
+
+- runtime model contracts
+- tool authoring contracts and `createTool`
+- plain message DTOs and presentation part types
+
+## Does not own
+
+- HTTP or gRPC transport details
+- parser or validation behavior
+- interaction state or framework bindings
+- storage, replay, queueing, or persistence strategy
+
+## Dependency direction
+
+Higher-level packages can depend on `@assistant-wi/core`, while `@assistant-wi/core`
+stays free of transport, UI, and orchestration concerns.
+
+## Runtime API relation
+
+`@assistant-wi/runtime` remains the transport-facing compatibility package for wire,
+codec, and protocol surfaces while re-exporting the core-owned runtime model layer.
+
+## Tool execution relation
+
+`@assistant-wi/interaction` can keep normalization and parser behavior while reusing
+the core-owned tool and message contracts.
+
+## Status
+
+Current foundational owner.

package/dist/assistant-parts.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,127 @@
+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

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

package/dist/index.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function n(t){const o=new Set;for(const e of t)e.type==="tool"&&(e.state==="done"||e.state==="error"||e.state==="canceled"||e.toolCallId.length>0&&o.add(e.toolCallId));return Array.from(o)}function r(t){return n(t).length>0?{version:1,code:"waiting_tool_outputs",reason:"system.awaiting_tool_outputs"}:{version:1,code:"completed",reason:"provider.stop"}}function s(t){return a(t),t}function a(t,o){if(typeof t.execute=="function")return;const e="createTool";throw new Error(`${e} now requires execute(); legacy workflow is no longer supported.`)}exports.collectPendingToolCallIdsFromAssistantParts=n;exports.createTool=s;exports.toDefaultStatusFromAssistantParts=r;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './shared';
+export * from './profile';
+export * from './sessions';
+export * from './tools';
+export * from './assistant-parts';
+export * from './messages';
+export * from './events';
+export * from './runtime-api';
+export * from './tool';
+export * from './part';
+export * from './status';
+export * from './feedback';
+export * from './message';
+export * from './message-data';
+export * from './session';

package/dist/index.es.js

@@ -0,0 +1,31 @@
+function n(t) {
+  const o = /* @__PURE__ */ new Set();
+  for (const e of t)
+    e.type === "tool" && (e.state === "done" || e.state === "error" || e.state === "canceled" || e.toolCallId.length > 0 && o.add(e.toolCallId));
+  return Array.from(o);
+}
+function s(t) {
+  return n(t).length > 0 ? {
+    version: 1,
+    code: "waiting_tool_outputs",
+    reason: "system.awaiting_tool_outputs"
+  } : {
+    version: 1,
+    code: "completed",
+    reason: "provider.stop"
+  };
+}
+function a(t) {
+  return r(t), t;
+}
+function r(t, o) {
+  if (typeof t.execute == "function")
+    return;
+  const e = "createTool";
+  throw new Error(`${e} now requires execute(); legacy workflow is no longer supported.`);
+}
+export {
+  n as collectPendingToolCallIdsFromAssistantParts,
+  a as createTool,
+  s as toDefaultStatusFromAssistantParts
+};

package/dist/message-data.d.ts

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

package/dist/message.d.ts

@@ -0,0 +1,16 @@
+import { MessageFeedbackType } from './feedback';
+import { MessagePart } from './part';
+import { MessageStatus } from './status';
+export type MessageRole = 'user' | 'assistant' | 'system';
+export interface Message {
+    id: string;
+    role: MessageRole;
+    parts: MessagePart[];
+    createdAt: Date;
+    status?: MessageStatus | undefined;
+    policy?: unknown | undefined;
+    rebased?: boolean | undefined;
+    feedbackType?: MessageFeedbackType | null | undefined;
+    feedbackReason?: string | null | undefined;
+    feedbackUpdatedAt?: Date | null | undefined;
+}

package/dist/messages.d.ts

@@ -0,0 +1,46 @@
+import { MessageFeedback } from './feedback';
+import { Message } from './message';
+import { MessagePart, MessagePartUnknown } from './part';
+import { MessageStatus, MessageStatusCode, MessageStatusReason } from './status';
+export type RuntimeMessage = Message;
+export type RuntimeMessageFeedback = MessageFeedback;
+export type RuntimeMessagePart = MessagePart;
+export type RuntimeUnknownMessagePart = MessagePartUnknown;
+export type RuntimeMessageStatus = MessageStatus;
+export type RuntimeMessageStatusCode = MessageStatusCode;
+export type RuntimeMessageStatusReason = MessageStatusReason;
+export type RuntimeMessagePage = {
+    items: Message[];
+    nextCursor: string | null;
+};
+export type RuntimeMessageQueryDirection = 'after' | 'before';
+export type RuntimeGetSessionMessagesParams = {
+    sessionId: string;
+    limit?: number;
+    cursor?: string;
+    direction?: RuntimeMessageQueryDirection;
+};
+export type RuntimeRespondUserMessagePart = {
+    type: string;
+    text?: string;
+    state?: string;
+    name?: string;
+    toolCallId?: string;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    [key: string]: unknown;
+};
+export type RuntimeRespondUserMessage = {
+    id: string;
+    role: 'user';
+    parts: RuntimeRespondUserMessagePart[];
+};
+export type RuntimeSetMessageFeedbackParams = {
+    sessionId: string;
+    messageId: string;
+    feedbackType: 'like' | 'dislike';
+    reason?: string;
+};
+export type { RuntimeAssistantFilePart, RuntimeAssistantPart, RuntimeAssistantProviderMetadata, RuntimeAssistantReasoningPart, RuntimeAssistantSourceDocumentPart, RuntimeAssistantSourceUrlPart, RuntimeAssistantTextPart, RuntimeAssistantToolApproval, RuntimeAssistantToolPart, RuntimeAssistantToolPartState, RuntimeAssistantUnknownPart, } from './assistant-parts';
+export { collectPendingToolCallIdsFromAssistantParts, toDefaultStatusFromAssistantParts, } from './assistant-parts';

package/dist/part.d.ts

@@ -0,0 +1,68 @@
+export type MessageProviderMetadata = Record<string, unknown>;
+export type MessageToolApproval = {
+    id: string;
+    approved?: boolean | undefined;
+    reason?: string | undefined;
+};
+export interface MessagePartReasoning {
+    type: 'reasoning';
+    text: string;
+    state: 'streaming' | 'done';
+    providerMetadata?: MessageProviderMetadata | undefined;
+    [key: string]: unknown;
+}
+export interface MessagePartText {
+    type: 'text';
+    text: string;
+    state: 'streaming' | 'done';
+    providerMetadata?: MessageProviderMetadata | undefined;
+    [key: string]: unknown;
+}
+export interface MessagePartTool {
+    type: 'tool';
+    name: string;
+    toolCallId: string;
+    input: unknown;
+    output?: unknown | undefined;
+    state: 'streaming' | 'call' | 'done' | 'error' | 'canceled';
+    error?: string | undefined;
+    providerExecuted?: boolean | undefined;
+    callProviderMetadata?: MessageProviderMetadata | undefined;
+    approval?: MessageToolApproval | undefined;
+    preliminary?: boolean | undefined;
+    title?: string | undefined;
+    [key: string]: unknown;
+}
+export interface MessagePartSourceUrl {
+    type: 'source-url';
+    sourceId: string;
+    url: string;
+    title?: string | undefined;
+    providerMetadata?: MessageProviderMetadata | undefined;
+    [key: string]: unknown;
+}
+export interface MessagePartSourceDocument {
+    type: 'source-document';
+    sourceId: string;
+    mediaType: string;
+    title: string;
+    filename?: string | undefined;
+    providerMetadata?: MessageProviderMetadata | undefined;
+    [key: string]: unknown;
+}
+export interface MessagePartFile {
+    type: 'file';
+    mediaType: string;
+    url: string;
+    filename?: string | undefined;
+    providerMetadata?: MessageProviderMetadata | undefined;
+    [key: string]: unknown;
+}
+export interface MessagePartUnknown {
+    type: 'unknown';
+    rawType?: string | undefined;
+    reason?: 'unsupported_chunk' | 'invalid_chunk' | undefined;
+    payload?: unknown | undefined;
+}
+export type MessagePart = MessageKnownPart | MessagePartUnknown;
+export type MessageKnownPart = MessagePartText | MessagePartTool | MessagePartReasoning | MessagePartSourceUrl | MessagePartSourceDocument | MessagePartFile;

package/dist/profile.d.ts

@@ -0,0 +1,42 @@
+export type RuntimeConfiguration = {
+    profile: {
+        id: string;
+        name: string;
+        description: string | null;
+    };
+    agents: RuntimeAgent[];
+    models: Model[];
+    limits: RuntimeConfigurationLimits;
+};
+export type RuntimeAgent = {
+    id: string;
+    name: string;
+};
+export type Model = {
+    id: string;
+    name: string;
+};
+export type RuntimeConfigurationLimits = {
+    maxMessages: number | null;
+    maxTokens: number | null;
+    messagesPerMinute: number | null;
+    messagesPerHour: number | null;
+    messagesPerDay: number | null;
+    messagesPerWeek: number | null;
+    messagesPerMonth: number | null;
+    weightedTokensPerHour: number | null;
+};
+export type RuntimeLimitRemainingWindow = {
+    limit: number;
+    used: number;
+    remaining: number;
+    resetAt: Date | null;
+};
+export type RuntimeRemainingLimits = {
+    messagesPerMinute: RuntimeLimitRemainingWindow | null;
+    messagesPerHour: RuntimeLimitRemainingWindow | null;
+    messagesPerDay: RuntimeLimitRemainingWindow | null;
+    messagesPerWeek: RuntimeLimitRemainingWindow | null;
+    messagesPerMonth: RuntimeLimitRemainingWindow | null;
+    weightedTokensPerHour: RuntimeLimitRemainingWindow | null;
+};

package/dist/runtime-api.d.ts

@@ -0,0 +1,88 @@
+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;
+    agentId: string;
+    modelId: string;
+    idempotencyKey: string;
+    message: RuntimeRespondUserMessage;
+    context?: string;
+    tools?: Record<string, unknown>;
+    signal?: AbortSignal;
+};
+export type RuntimeCreateResponseResult = {
+    responseId: string;
+    sessionId: string;
+    userMessageId: string;
+    runId: string;
+};
+export type RuntimeContinueRunParams = {
+    responseId: string;
+    runId: string;
+    idempotencyKey: string;
+    signal?: AbortSignal;
+};
+export type RuntimeContinueRunResult = {
+    responseId: string;
+    runId: string;
+    status: Extract<RuntimeRunStatus, 'queued'>;
+};
+export type RuntimeGetSessionMessageRunParams = {
+    sessionId: string;
+    assistantMessageId: string;
+    signal?: AbortSignal;
+};
+export type RuntimeMessageRun = {
+    responseId: string;
+    runId: string;
+    status: RuntimeRunStatus;
+    reason: string | null;
+};
+export type RuntimeCancelRunParams = {
+    responseId: string;
+    runId: string;
+    reason?: 'user.cancelled' | 'client.unsync';
+    signal?: AbortSignal;
+};
+export type RuntimeCancelRunResult = {
+    responseId: string;
+    runId: string;
+    status: Extract<RuntimeRunStatus, 'cancelled'>;
+};
+export type RuntimeCommitToolOutputsParams = {
+    responseId: string;
+    runId: string;
+    toolOutputs: RuntimeToolOutputCommitRequest[];
+    signal?: AbortSignal;
+};
+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>>;
+};

package/dist/session.d.ts

@@ -0,0 +1,16 @@
+export type Session = {
+    id: string;
+    title: string | null;
+    starred: boolean;
+    lastActivityAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type SessionPage = {
+    items: Session[];
+    nextCursor: string | null;
+};
+export type SessionStar = {
+    sessionId: string;
+    starred: boolean;
+};

package/dist/sessions.d.ts

@@ -0,0 +1,13 @@
+import { Session, SessionPage, SessionStar } from './session';
+export type RuntimeSession = Session;
+export type RuntimeSessionPage = SessionPage;
+export type RuntimeSessionStar = SessionStar;
+export type RuntimeGetSessionsParams = {
+    limit?: number;
+    cursor?: string;
+    starred?: boolean;
+    query?: string;
+};
+export type RuntimeCreateSessionParams = {
+    title?: string;
+};

package/dist/shared.d.ts

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

package/dist/status.d.ts

@@ -0,0 +1,7 @@
+export type MessageStatusCode = 'in_progress' | 'waiting_tool_outputs' | 'completed' | 'interrupted' | 'failed';
+export type MessageStatusReason = 'system.started' | 'system.resumed' | 'system.awaiting_tool_outputs' | 'system.timeout' | 'system.resume_unavailable' | 'system.internal_error' | 'system.network_error' | 'system.stream_corrupted' | 'system.runtime_protocol_violation' | 'system.lease_expired' | 'user.cancelled' | 'provider.stop' | 'provider.max_tokens' | 'provider.content_filtered' | 'provider.other_finish_reason' | 'provider.error';
+export type MessageStatus = {
+    version: 1;
+    code: MessageStatusCode;
+    reason: MessageStatusReason;
+};

package/dist/tool.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from 'ai';
+import { default as z } from 'zod/v4';
+export type ToolSignature = {
+    description: string;
+    claim?: 'required' | 'optional' | undefined;
+    inputSchema: Schema;
+    outputSchema: Schema;
+};
+export type ToolSignatures = Record<string, ToolSignature>;
+export type Tools = Record<string, Tool>;
+export interface Tool<I extends z.ZodTypeAny = z.ZodTypeAny, O extends z.ZodTypeAny = z.ZodTypeAny> {
+    description: string;
+    claim?: 'required' | 'optional' | undefined;
+    inputSchema: I;
+    outputSchema: O;
+    execute: (props: ToolExecuteProps<I>) => Promise<z.infer<O>>;
+}
+export interface ToolExecuteProps<Input extends z.ZodTypeAny> {
+    toolCallId: string;
+    input: z.infer<Input>;
+}
+export declare function createTool<I extends z.ZodTypeAny, O extends z.ZodTypeAny>(tool: Tool<I, O>): Tool<I, O>;

package/dist/tools.d.ts

@@ -0,0 +1,39 @@
+export type RuntimeToolClaimPolicy = 'required' | 'optional';
+export type RuntimeToolSignature = {
+    description: string;
+    claim?: RuntimeToolClaimPolicy | undefined;
+    inputSchema: {
+        jsonSchema: Record<string, unknown>;
+    };
+    outputSchema: {
+        jsonSchema: Record<string, unknown>;
+    };
+};
+export type RuntimeToolClaim = {
+    toolCallId: string;
+    claimToken: string;
+    claimExpiresAt: Date;
+    operationKey: string;
+    claim: RuntimeToolClaimPolicy;
+};
+export type RuntimeToolOutputOutcome = 'success' | 'error' | 'denied';
+export type RuntimeToolOutputCommitRequest = {
+    toolCallId: string;
+    claimToken?: string;
+    outcome: RuntimeToolOutputOutcome;
+    output?: unknown;
+    error?: string;
+};
+export type RuntimeToolClaimRequest = {
+    responseId: string;
+    runId: string;
+    toolCallId: string;
+    signal?: AbortSignal;
+};
+export type RuntimeToolClaimRenewParams = {
+    responseId: string;
+    runId: string;
+    toolCallId: string;
+    claimToken: string;
+    signal?: AbortSignal;
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@assistant-wi/core",
+  "private": false,
+  "version": "0.0.1-alpha.7",
+  "type": "module",
+  "description": "Core runtime contracts, tool authoring primitives, and message DTOs for assistant-wi",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs.js",
+      "default": "./dist/index.es.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noEmit && vite build -c vite.config.ts",
+    "test": "bun test src"
+  },
+  "dependencies": {
+    "ai": "6",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}