@inf-minds/mindkit 0.0.1

package/src/providers/select.ts

@@ -0,0 +1,56 @@
+// ABOUTME: Model selection logic for mindkit
+// ABOUTME: Auto-detects provider from model ID and creates appropriate model instance
+
+import type { LanguageModel } from 'ai';
+import { createAnthropicModel } from './anthropic.js';
+import { createOpenAIModel } from './openai.js';
+
+export type ModelProvider = 'anthropic' | 'openai';
+
+/**
+ * Detect provider from model ID
+ * @param modelId - Model identifier
+ * @returns Detected provider
+ */
+export function detectProvider(modelId: string): ModelProvider {
+  // Anthropic models
+  if (
+    modelId.includes('claude') ||
+    modelId.startsWith('claude-')
+  ) {
+    return 'anthropic';
+  }
+
+  // OpenAI models
+  if (
+    modelId.includes('gpt') ||
+    modelId.startsWith('gpt-') ||
+    modelId.startsWith('o1') ||
+    modelId.startsWith('o3')
+  ) {
+    return 'openai';
+  }
+
+  // Default to OpenAI for unknown models
+  return 'openai';
+}
+
+/**
+ * Select and create model instance based on model ID and optional provider override
+ * @param modelId - Model identifier
+ * @param provider - Optional provider override
+ * @param apiKey - Optional API key (required for edge runtimes like Cloudflare Workers)
+ * @returns Model instance
+ */
+export function selectModel(modelId: string, provider?: ModelProvider, apiKey?: string): LanguageModel {
+  const resolvedProvider = provider ?? detectProvider(modelId);
+
+  switch (resolvedProvider) {
+    case 'anthropic':
+      return createAnthropicModel(modelId, apiKey);
+    case 'openai':
+      return createOpenAIModel(modelId, apiKey);
+    default:
+      throw new Error(`Unknown provider: ${resolvedProvider}`);
+  }
+}

package/src/types.ts

@@ -0,0 +1,147 @@
+// ABOUTME: Core types for mindkit - Mind, MindConfig, MindExtension, MindEvent
+// ABOUTME: Defines the interface for single mind runtime using Mastra
+
+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;
+}