kernl 0.1.3 → 0.2.0

package/src/tool/toolkit.ts

@@ -18,12 +18,17 @@ import type {
  * Toolkits can be static (FunctionToolkit) or dynamic (MCPToolkit), and provide
  * a unified interface for tool discovery and management.
  */
-export abstract class Toolkit<TContext = UnknownContext> {
+export abstract class BaseToolkit<TContext = UnknownContext> {
   /**
    * Unique identifier for this toolkit
    */
   abstract readonly id: string;
 
+  /**
+   * Description of what this toolkit provides
+   */
+  abstract readonly description: string;
+
   /**
    * The agent this toolkit is bound to (if any)
    */
@@ -77,8 +82,9 @@ export abstract class Toolkit<TContext = UnknownContext> {
  */
 export class FunctionToolkit<
   TContext = UnknownContext,
-> extends Toolkit<TContext> {
+> extends BaseToolkit<TContext> {
   readonly id: string;
+  readonly description: string;
   private tools: Map<string, Tool<TContext>>;
 
   /**
@@ -89,6 +95,7 @@ export class FunctionToolkit<
   constructor(config: FunctionToolkitConfig<TContext>) {
     super();
     this.id = config.id;
+    this.description = config.description ?? "";
     this.tools = new Map(config.tools.map((t) => [t.id, t]));
   }
 
@@ -113,6 +120,11 @@ export class FunctionToolkit<
   }
 }
 
+/**
+ * Convenience alias for FunctionToolkit - the default toolkit implementation.
+ */
+export { FunctionToolkit as Toolkit };
+
 /*
  * A toolkit that wraps an MCP server and provides tools from it.
  *
@@ -144,8 +156,11 @@ export class FunctionToolkit<
  * });
  * ```
  */
-export class MCPToolkit<TContext = UnknownContext> extends Toolkit<TContext> {
+export class MCPToolkit<
+  TContext = UnknownContext,
+> extends BaseToolkit<TContext> {
   readonly id: string;
+  readonly description: string;
   private server: MCPServer;
   private cache: Map<string, Tool<TContext>>;
   private filter: ToolkitFilter<TContext>;
@@ -161,6 +176,7 @@ export class MCPToolkit<TContext = UnknownContext> extends Toolkit<TContext> {
   constructor(config: MCPToolkitConfig<TContext>) {
     super();
     this.id = config.id;
+    this.description = config.description ?? "";
     this.server = config.server;
     this.filter = config.filter ?? (() => true);
     this.cache = new Map();

package/src/tool/types.ts

@@ -121,6 +121,11 @@ export interface FunctionToolkitConfig<TContext = UnknownContext> {
    */
   id: string;
 
+  /**
+   * Optional description of what this toolkit provides.
+   */
+  description?: string;
+
   /**
    * Array of tools to include in this toolkit.
    */
@@ -136,6 +141,11 @@ export interface MCPToolkitConfig<TContext = UnknownContext> {
    */
   id: string;
 
+  /**
+   * Optional description of what this toolkit provides.
+   */
+  description?: string;
+
   /**
    * The MCP server instance to wrap.
    */

package/src/types/agent.ts

@@ -1,9 +1,12 @@
 import { type ZodType } from "zod";
 
 import { Context, UnknownContext } from "@/context";
-import { LanguageModel, LanguageModelRequestSettings } from "@kernl-sdk/protocol";
+import {
+  LanguageModel,
+  LanguageModelRequestSettings,
+} from "@kernl-sdk/protocol";
 import { InputGuardrail, OutputGuardrail } from "@/guardrail";
-import { Toolkit } from "@/tool";
+import { BaseToolkit } from "@/tool";
 
 import { TextResponse } from "./thread";
 
@@ -50,7 +53,7 @@ export interface AgentConfig<
    *
    * By default, if not set, the agent will use a default model that throws an error when called.
    */
-  model?: LanguageModel;
+  model: LanguageModel;
 
   /**
    * Configures model-specific tuning parameters (e.g. temperature, top_p, etc.)
@@ -59,11 +62,11 @@ export interface AgentConfig<
 
   /**
    * A list of toolkits the agent can use. Toolkits are collections of related tools
-   * that can be static (FunctionToolkit) or dynamic (MCPToolkit).
+   * that can be static (Toolkit) or dynamic (MCPToolkit).
    *
    * @example
    * ```typescript
-   * const myTools = new FunctionToolkit({
+   * const myTools = new Toolkit({
    *   id: "custom",
    *   tools: [tool1, tool2]
    * });
@@ -80,7 +83,7 @@ export interface AgentConfig<
    * });
    * ```
    */
-  toolkits?: Toolkit<TContext>[];
+  toolkits?: BaseToolkit<TContext>[];
 
   /**
    * A list of checks that run in parallel to the agent's execution on the input + output for the agent,

package/src/types/thread.ts

@@ -3,11 +3,30 @@ import {
   LanguageModel,
   LanguageModelItem,
   LanguageModelStreamEvent,
+  RUNNING,
+  STOPPED,
+  INTERRUPTIBLE,
+  UNINTERRUPTIBLE,
+  ZOMBIE,
+  DEAD,
 } from "@kernl-sdk/protocol";
 
 import { Task } from "@/task";
 import { Context } from "@/context";
 
+export type TextResponse = "text";
+
+/**
+ * Thread state discriminated union
+ */
+export type ThreadState =
+  | typeof RUNNING
+  | typeof STOPPED
+  | typeof INTERRUPTIBLE
+  | typeof UNINTERRUPTIBLE
+  | typeof ZOMBIE
+  | typeof DEAD;
+
 /**
  * Thread-specific tool call state for approval workflow.
  * This extends the protocol states for internal thread use.
@@ -35,20 +54,6 @@ export interface ActionSet {
   // Future: other actions, mcpRequests, etc.
 }
 
-/**
- * Result of a single tick of execution
- */
-export interface TickResult {
-  /**
-   * Events to add to thread history
-   */
-  events: ThreadEvent[];
-  /**
-   * Action intentions that need to be performed as a result of this tick
-   */
-  intentions: ActionSet | null;
-}
-
 /**
  * Result of performing actions, including both executed results and pending approvals
  */
@@ -79,8 +84,11 @@ export interface ThreadExecuteResult<TResponse = any> {
 
 export interface ThreadOptions<TContext> {
   context: Context<TContext>;
-  task?: Task<TContext>;
   model?: LanguageModel;
-}
+  task?: Task<TContext>;
+  threadId?: string;
+  maxTicks?: number;
+  abort?: AbortSignal;
 
-export type TextResponse = "text";
+  // conversationId?: string;
+}