@inf-minds/mindkit 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,156 @@
+import type { ArtifactRef, VisibilityHints } from '@inf-minds/jobs';
+/**
+ * Unique ID generator type
+ */
+export type GenerateId = () => string;
+/**
+ * Unsubscribe function returned by subscribe methods
+ */
+export type Unsubscribe = () => void;
+/**
+ * Token usage statistics from LLM calls
+ */
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Tool definition for minds
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (args: unknown) => Promise<unknown>;
+}
+/**
+ * Mind configuration
+ */
+export interface MindConfig {
+    /** Model identifier (e.g., 'claude-sonnet-4-20250514', 'gpt-4o') */
+    model: string;
+    /** LLM provider - auto-detected from model if not specified */
+    provider?: 'anthropic' | 'openai';
+    /** API key for the provider (required for edge runtimes like Cloudflare Workers) */
+    apiKey?: string;
+    /** System prompt for the mind */
+    systemPrompt?: string;
+    /** Tools available to the mind */
+    tools?: ToolDefinition[];
+    /** Maximum tokens for completion */
+    maxTokens?: number;
+    /** Temperature for sampling */
+    temperature?: number;
+    /** Extensions to compose into the mind */
+    extensions?: MindExtension[];
+}
+/**
+ * Input to a mind execution
+ */
+export interface MindInput {
+    /** The task or prompt for the mind */
+    task: string;
+    /** Additional context data */
+    context?: Record<string, unknown>;
+    /** Artifact references available to the mind */
+    artifacts?: ArtifactRef[];
+    /** Artifact paths to load */
+    artifactPaths?: string[];
+}
+/**
+ * Artifact with visibility hints from mind output
+ */
+export interface ArtifactWithHints {
+    ref: ArtifactRef;
+    hints: VisibilityHints;
+}
+/**
+ * Output from a mind execution
+ */
+export interface MindOutput {
+    /** The result from the mind */
+    result: unknown;
+    /** Artifacts created by the mind with visibility hints */
+    artifacts?: ArtifactWithHints[];
+    /** Token usage statistics */
+    usage?: TokenUsage;
+}
+/**
+ * Mind extension for composable functionality
+ */
+export interface MindExtension {
+    /** Extension name */
+    name: string;
+    /** Additional system prompt content */
+    systemPromptAddition?: string;
+    /** Additional tools provided by the extension */
+    tools?: ToolDefinition[];
+    /** Preprocess input before execution */
+    preprocessInput?: (input: MindInput) => MindInput;
+    /** Postprocess output after execution */
+    postprocessOutput?: (output: MindOutput) => MindOutput;
+}
+/**
+ * Events emitted during mind execution
+ */
+export type MindEvent = {
+    type: 'started';
+    timestamp: Date;
+} | {
+    type: 'thinking';
+    content: string;
+} | {
+    type: 'tool_call';
+    tool: string;
+    args: unknown;
+} | {
+    type: 'tool_result';
+    tool: string;
+    result: unknown;
+} | {
+    type: 'text_delta';
+    delta: string;
+} | {
+    type: 'artifact_created';
+    ref: ArtifactRef;
+    hints: VisibilityHints;
+} | {
+    type: 'progress';
+    percent: number;
+    message?: string;
+} | {
+    type: 'completed';
+    output: MindOutput;
+} | {
+    type: 'failed';
+    error: string;
+};
+/**
+ * Mind runtime interface
+ */
+export interface Mind {
+    /** Unique mind instance ID */
+    readonly id: string;
+    /** Mind configuration */
+    readonly config: MindConfig;
+    /**
+     * Execute the mind with the given input
+     * @param input - Task and context for execution
+     * @returns Mind output with result and artifacts
+     */
+    run(input: MindInput): Promise<MindOutput>;
+    /**
+     * Execute the mind with streaming events
+     * @param input - Task and context for execution
+     * @returns Async iterable of mind events
+     */
+    stream(input: MindInput): AsyncIterable<MindEvent>;
+    /**
+     * Subscribe to mind events during execution
+     * @param handler - Event handler function
+     * @returns Unsubscribe function
+     */
+    subscribe(handler: (event: MindEvent) => void): Unsubscribe;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,4 @@
+// ABOUTME: Core types for mindkit - Mind, MindConfig, MindExtension, MindEvent
+// ABOUTME: Defines the interface for single mind runtime using Mastra
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,sEAAsE"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@inf-minds/mindkit",
+  "version": "0.0.1",
+  "description": "Single mind runtime using Mastra for LLM orchestration",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo 'No linter configured yet'"
+  },
+  "dependencies": {
+    "ai": "^3.4.0",
+    "zod": "^3.23.8",
+    "@ai-sdk/anthropic": "^1.0.0",
+    "@ai-sdk/openai": "^1.0.0",
+    "@inf-minds/jobs": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependencies": {
+    "ai": ">=3.0.0"
+  }
+}

package/src/extensions/index.ts

@@ -0,0 +1,7 @@
+// ABOUTME: Built-in extensions for mindkit
+// ABOUTME: Exports composable functionality extensions
+
+// Extensions will be implemented in future phases
+// This file serves as the extension export point
+
+export {};

package/src/index.ts

@@ -0,0 +1,32 @@
+// ABOUTME: Mindkit package entry point
+// ABOUTME: Exports Mind types, createMind factory, and provider adapters
+
+// Type exports
+export type {
+  Mind,
+  MindConfig,
+  MindInput,
+  MindOutput,
+  MindEvent,
+  MindExtension,
+  ToolDefinition,
+  TokenUsage,
+  ArtifactWithHints,
+  Unsubscribe,
+  GenerateId,
+} from './types.js';
+
+// Factory exports
+export { createMind, type CreateMindOptions } from './mind.js';
+
+// Provider exports
+export {
+  createAnthropicModel,
+  createOpenAIModel,
+  selectModel,
+  detectProvider,
+  type ModelProvider,
+} from './providers/index.js';
+
+// Extension exports (placeholder for future extensions)
+export * from './extensions/index.js';

package/src/mind.ts

@@ -0,0 +1,348 @@
+// ABOUTME: Mind factory for creating mind instances
+// ABOUTME: Uses Vercel AI SDK for LLM orchestration
+
+import { generateText, streamText, tool, type CoreMessage, type LanguageModel } from 'ai';
+import { z } from 'zod';
+import { selectModel } from './providers/index.js';
+import type {
+  Mind,
+  MindConfig,
+  MindInput,
+  MindOutput,
+  MindEvent,
+  MindExtension,
+  ToolDefinition,
+  Unsubscribe,
+  GenerateId,
+} from './types.js';
+
+/**
+ * Default ID generator using crypto.randomUUID
+ */
+const defaultGenerateId: GenerateId = () => crypto.randomUUID();
+
+/**
+ * Options for creating a mind
+ */
+export interface CreateMindOptions extends MindConfig {
+  /** Custom ID generator */
+  generateId?: GenerateId;
+}
+
+/**
+ * Build the final system prompt from base config and extensions
+ */
+function buildSystemPrompt(config: MindConfig): string {
+  const parts: string[] = [];
+
+  // Base system prompt
+  if (config.systemPrompt) {
+    parts.push(config.systemPrompt);
+  }
+
+  // Extension additions
+  if (config.extensions) {
+    for (const ext of config.extensions) {
+      if (ext.systemPromptAddition) {
+        parts.push(ext.systemPromptAddition);
+      }
+    }
+  }
+
+  return parts.join('\n\n');
+}
+
+/**
+ * Collect tools from config and extensions
+ */
+function collectTools(config: MindConfig): ToolDefinition[] {
+  const tools: ToolDefinition[] = [];
+
+  // Base tools
+  if (config.tools) {
+    tools.push(...config.tools);
+  }
+
+  // Extension tools
+  if (config.extensions) {
+    for (const ext of config.extensions) {
+      if (ext.tools) {
+        tools.push(...ext.tools);
+      }
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * Apply extension preprocessors to input
+ */
+function preprocessInput(input: MindInput, extensions?: MindExtension[]): MindInput {
+  let processed = input;
+
+  if (extensions) {
+    for (const ext of extensions) {
+      if (ext.preprocessInput) {
+        processed = ext.preprocessInput(processed);
+      }
+    }
+  }
+
+  return processed;
+}
+
+/**
+ * Apply extension postprocessors to output
+ */
+function postprocessOutput(output: MindOutput, extensions?: MindExtension[]): MindOutput {
+  let processed = output;
+
+  if (extensions) {
+    for (const ext of extensions) {
+      if (ext.postprocessOutput) {
+        processed = ext.postprocessOutput(processed);
+      }
+    }
+  }
+
+  return processed;
+}
+
+/**
+ * Convert tool definitions to Vercel AI SDK tool format
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function convertToolsToAI(tools: ToolDefinition[]): Record<string, any> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const aiTools: Record<string, any> = {};
+
+  for (const toolDef of tools) {
+    // Convert parameters to zod schema if it's a plain object
+    const parametersSchema =
+      toolDef.parameters instanceof z.ZodType
+        ? toolDef.parameters
+        : z.object(toolDef.parameters as Record<string, z.ZodTypeAny>);
+
+    aiTools[toolDef.name] = tool({
+      description: toolDef.description,
+      parameters: parametersSchema,
+      execute: toolDef.execute as (args: unknown) => Promise<unknown>,
+    });
+  }
+
+  return aiTools;
+}
+
+/**
+ * Build messages array from input
+ */
+function buildMessages(systemPrompt: string, input: MindInput): CoreMessage[] {
+  const messages: CoreMessage[] = [];
+
+  // Add system message if provided
+  if (systemPrompt) {
+    messages.push({ role: 'system', content: systemPrompt });
+  }
+
+  // Build user message with context
+  let userContent = input.task;
+  if (input.context) {
+    userContent = `Context:\n${JSON.stringify(input.context, null, 2)}\n\nTask:\n${input.task}`;
+  }
+
+  messages.push({ role: 'user', content: userContent });
+
+  return messages;
+}
+
+/**
+ * Mind implementation using Vercel AI SDK
+ */
+class MindImpl implements Mind {
+  readonly id: string;
+  readonly config: MindConfig;
+  private systemPrompt: string;
+  private toolDefs: ToolDefinition[];
+  private model: LanguageModel;
+  private subscribers: Set<(event: MindEvent) => void> = new Set();
+
+  constructor(
+    id: string,
+    config: MindConfig,
+    systemPrompt: string,
+    toolDefs: ToolDefinition[],
+    model: LanguageModel
+  ) {
+    this.id = id;
+    this.config = config;
+    this.systemPrompt = systemPrompt;
+    this.toolDefs = toolDefs;
+    this.model = model;
+  }
+
+  private emit(event: MindEvent): void {
+    for (const handler of this.subscribers) {
+      try {
+        handler(event);
+      } catch {
+        // Ignore subscriber errors
+      }
+    }
+  }
+
+  async run(input: MindInput): Promise<MindOutput> {
+    // Preprocess input
+    const processedInput = preprocessInput(input, this.config.extensions);
+
+    // Emit started event
+    this.emit({ type: 'started', timestamp: new Date() });
+
+    try {
+      // Build messages
+      const messages = buildMessages(this.systemPrompt, processedInput);
+
+      // Convert tools
+      const tools = this.toolDefs.length > 0 ? convertToolsToAI(this.toolDefs) : undefined;
+
+      // Execute via Vercel AI SDK
+      const result = await generateText({
+        model: this.model,
+        messages,
+        tools,
+        maxSteps: 10,
+        maxTokens: this.config.maxTokens,
+        temperature: this.config.temperature,
+      });
+
+      // Build output
+      const output: MindOutput = {
+        result: result.text,
+        usage: result.usage
+          ? {
+              promptTokens: result.usage.promptTokens ?? 0,
+              completionTokens: result.usage.completionTokens ?? 0,
+              totalTokens: (result.usage.promptTokens ?? 0) + (result.usage.completionTokens ?? 0),
+            }
+          : undefined,
+      };
+
+      // Postprocess output
+      const processedOutput = postprocessOutput(output, this.config.extensions);
+
+      // Emit completed event
+      this.emit({ type: 'completed', output: processedOutput });
+
+      return processedOutput;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.emit({ type: 'failed', error: errorMessage });
+      throw error;
+    }
+  }
+
+  async *stream(input: MindInput): AsyncIterable<MindEvent> {
+    // Preprocess input
+    const processedInput = preprocessInput(input, this.config.extensions);
+
+    // Emit started event
+    const startedEvent: MindEvent = { type: 'started', timestamp: new Date() };
+    this.emit(startedEvent);
+    yield startedEvent;
+
+    try {
+      // Build messages
+      const messages = buildMessages(this.systemPrompt, processedInput);
+
+      // Convert tools
+      const tools = this.toolDefs.length > 0 ? convertToolsToAI(this.toolDefs) : undefined;
+
+      // Stream via Vercel AI SDK - streamText returns a Promise
+      const streamResult = await streamText({
+        model: this.model,
+        messages,
+        tools,
+        maxSteps: 10,
+        maxTokens: this.config.maxTokens,
+        temperature: this.config.temperature,
+      });
+
+      let fullText = '';
+
+      // Process stream chunks - fullStream is an AsyncIterable
+      for await (const chunk of streamResult.fullStream) {
+        if (chunk.type === 'text-delta') {
+          const event: MindEvent = { type: 'text_delta', delta: chunk.textDelta };
+          fullText += chunk.textDelta;
+          this.emit(event);
+          yield event;
+        } else if (chunk.type === 'tool-call') {
+          const event: MindEvent = { type: 'tool_call', tool: chunk.toolName, args: chunk.args };
+          this.emit(event);
+          yield event;
+        } else if (chunk.type === 'tool-result') {
+          const event: MindEvent = { type: 'tool_result', tool: chunk.toolName, result: chunk.result };
+          this.emit(event);
+          yield event;
+        }
+      }
+
+      // Get final usage - usage is a promise that resolves after stream completes
+      const usage = await streamResult.usage;
+
+      // Build output
+      const output: MindOutput = {
+        result: fullText,
+        usage: usage
+          ? {
+              promptTokens: usage.promptTokens ?? 0,
+              completionTokens: usage.completionTokens ?? 0,
+              totalTokens: (usage.promptTokens ?? 0) + (usage.completionTokens ?? 0),
+            }
+          : undefined,
+      };
+
+      // Postprocess output
+      const processedOutput = postprocessOutput(output, this.config.extensions);
+
+      // Emit completed event
+      const completedEvent: MindEvent = { type: 'completed', output: processedOutput };
+      this.emit(completedEvent);
+      yield completedEvent;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const failedEvent: MindEvent = { type: 'failed', error: errorMessage };
+      this.emit(failedEvent);
+      yield failedEvent;
+      throw error;
+    }
+  }
+
+  subscribe(handler: (event: MindEvent) => void): Unsubscribe {
+    this.subscribers.add(handler);
+    return () => {
+      this.subscribers.delete(handler);
+    };
+  }
+}
+
+/**
+ * Create a mind instance
+ * @param options - Mind configuration and options
+ * @returns Mind instance
+ */
+export function createMind(options: CreateMindOptions): Mind {
+  const generateId = options.generateId ?? defaultGenerateId;
+  const id = generateId();
+
+  // Build system prompt
+  const systemPrompt = buildSystemPrompt(options);
+
+  // Collect tools (keep as definitions, convert at runtime)
+  const toolDefs = collectTools(options);
+
+  // Select model based on config
+  const model = selectModel(options.model, options.provider, options.apiKey);
+
+  return new MindImpl(id, options, systemPrompt, toolDefs, model);
+}

package/src/providers/anthropic.ts

@@ -0,0 +1,22 @@
+// ABOUTME: Anthropic provider adapter for mindkit
+// ABOUTME: Creates Anthropic model instances using @ai-sdk/anthropic
+
+import { createAnthropic, anthropic } from '@ai-sdk/anthropic';
+import type { LanguageModel } from 'ai';
+
+/**
+ * Create an Anthropic model instance
+ * @param modelId - Model identifier (e.g., 'claude-sonnet-4-20250514')
+ * @param apiKey - Optional API key (required for edge runtimes like Cloudflare Workers)
+ * @returns Anthropic model instance
+ */
+export function createAnthropicModel(modelId: string, apiKey?: string): LanguageModel {
+  // Cast needed due to version differences between @ai-sdk/anthropic and ai package
+  if (apiKey) {
+    // Use explicit API key for edge runtimes that don't have process.env
+    const anthropicClient = createAnthropic({ apiKey });
+    return anthropicClient(modelId) as unknown as LanguageModel;
+  }
+  // Fallback to env var for Node.js environments
+  return anthropic(modelId) as unknown as LanguageModel;
+}

package/src/providers/index.ts

@@ -0,0 +1,6 @@
+// ABOUTME: LLM provider adapters for mindkit
+// ABOUTME: Exports provider creation functions for Anthropic and OpenAI
+
+export { createAnthropicModel } from './anthropic.js';
+export { createOpenAIModel } from './openai.js';
+export { selectModel, detectProvider, type ModelProvider } from './select.js';

package/src/providers/openai.ts

@@ -0,0 +1,22 @@
+// ABOUTME: OpenAI provider adapter for mindkit
+// ABOUTME: Creates OpenAI model instances using @ai-sdk/openai
+
+import { createOpenAI, openai } from '@ai-sdk/openai';
+import type { LanguageModel } from 'ai';
+
+/**
+ * Create an OpenAI model instance
+ * @param modelId - Model identifier (e.g., 'gpt-4o')
+ * @param apiKey - Optional API key (required for edge runtimes like Cloudflare Workers)
+ * @returns OpenAI model instance
+ */
+export function createOpenAIModel(modelId: string, apiKey?: string): LanguageModel {
+  // Cast needed due to version differences between @ai-sdk/openai and ai package
+  if (apiKey) {
+    // Use explicit API key for edge runtimes that don't have process.env
+    const openaiClient = createOpenAI({ apiKey });
+    return openaiClient(modelId) as unknown as LanguageModel;
+  }
+  // Fallback to env var for Node.js environments
+  return openai(modelId) as unknown as LanguageModel;
+}