@poncho-ai/harness 0.25.0 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/harness",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "description": "Agent execution runtime - conversation loop, tool dispatch, streaming",
   "repository": {
     "type": "git",
@@ -31,7 +31,7 @@
     "redis": "^5.10.0",
     "yaml": "^2.4.0",
     "zod": "^3.22.0",
-    "@poncho-ai/sdk": "1.5.0"
+    "@poncho-ai/sdk": "1.6.0"
   },
   "devDependencies": {
     "@types/mustache": "^4.2.6",

package/src/config.ts

@@ -42,6 +42,10 @@ export type BuiltInToolToggles = {
   edit_file?: boolean;
   delete_file?: boolean;
   delete_directory?: boolean;
+  todo_list?: boolean;
+  todo_add?: boolean;
+  todo_update?: boolean;
+  todo_remove?: boolean;
 };
 
 export interface MessagingChannelConfig {

package/src/harness.ts

@@ -16,13 +16,14 @@ import { getTextContent } from "@poncho-ai/sdk";
 import type { UploadStore } from "./upload-store.js";
 import { PONCHO_UPLOAD_SCHEME, deriveUploadKey } from "./upload-store.js";
 import { parseAgentFile, parseAgentMarkdown, renderAgentPrompt, type ParsedAgent, type AgentFrontmatter } from "./agent-parser.js";
-import { loadPonchoConfig, resolveMemoryConfig, type PonchoConfig, type ToolAccess, type BuiltInToolToggles } from "./config.js";
+import { loadPonchoConfig, resolveMemoryConfig, resolveStateConfig, type PonchoConfig, type ToolAccess, type BuiltInToolToggles } from "./config.js";
 import { createDefaultTools, createDeleteDirectoryTool, createDeleteTool, createEditTool, createWriteTool, ponchoDocsTool } from "./default-tools.js";
 import {
   createMemoryStore,
   createMemoryTools,
   type MemoryStore,
 } from "./memory.js";
+import { createTodoStore, createTodoTools, type TodoItem, type TodoStore } from "./todo-tools.js";
 import { LocalMcpBridge } from "./mcp.js";
 import { createModelProvider, getModelContextWindow, type ModelProviderFactory, type ProviderConfig } from "./model-factory.js";
 import { buildSkillContextWindow, loadSkillMetadata } from "./skill-context.js";
@@ -550,6 +551,7 @@ export class AgentHarness {
   readonly uploadStore?: UploadStore;
   private skillContextWindow = "";
   private memoryStore?: MemoryStore;
+  private todoStore?: TodoStore;
   private loadedConfig?: PonchoConfig;
   private loadedSkills: SkillMetadata[] = [];
   private skillFingerprint = "";
@@ -560,7 +562,7 @@ export class AgentHarness {
   private insideTelemetryCapture = false;
   private _browserSession?: unknown;
   private _browserMod?: {
-    createBrowserTools: (getSession: () => unknown, getConversationId: () => string) => ToolDefinition[];
+    createBrowserTools: (getSession: () => unknown) => ToolDefinition[];
     BrowserSession: new (sessionId: string, config: Record<string, unknown>) => unknown;
   };
 
@@ -620,11 +622,7 @@ export class AgentHarness {
   setSubagentManager(manager: SubagentManager): void {
     this.subagentManager = manager;
     this.dispatcher.registerMany(
-      createSubagentTools(
-        manager,
-        () => this._currentRunConversationId,
-        () => this._currentRunOwnerId ?? "anonymous",
-      ),
+      createSubagentTools(manager),
     );
   }
 
@@ -678,6 +676,11 @@ export class AgentHarness {
     return this.parsedAgent?.frontmatter;
   }
 
+  async getTodos(conversationId: string): Promise<TodoItem[]> {
+    if (!this.todoStore) return [];
+    return this.todoStore.get(conversationId);
+  }
+
   private listActiveSkills(): string[] {
     return [...this.activeSkillNames].sort();
   }
@@ -1008,8 +1011,9 @@ export class AgentHarness {
     this.skillContextWindow = buildSkillContextWindow(skillMetadata);
     this.skillFingerprint = this.buildSkillFingerprint(skillMetadata);
     this.registerSkillTools(skillMetadata);
+    const agentId = this.parsedAgent.frontmatter.id ?? this.parsedAgent.frontmatter.name;
+
     if (memoryConfig?.enabled) {
-      const agentId = this.parsedAgent.frontmatter.id ?? this.parsedAgent.frontmatter.name;
       this.memoryStore = createMemoryStore(
         agentId,
         memoryConfig,
@@ -1022,6 +1026,14 @@ export class AgentHarness {
       );
     }
 
+    const stateConfig = resolveStateConfig(config);
+    this.todoStore = createTodoStore(agentId, stateConfig, { workingDir: this.workingDir });
+    for (const tool of createTodoTools(this.todoStore)) {
+      if (this.isToolEnabled(tool.name)) {
+        this.registerIfMissing(tool);
+      }
+    }
+
     if (config?.browser) {
       await this.initBrowserTools(config)
         .catch((e) => {
@@ -1149,7 +1161,7 @@ export class AgentHarness {
   private async initBrowserTools(config: PonchoConfig): Promise<void> {
     const spec = ["@poncho-ai", "browser"].join("/");
     let browserMod: {
-      createBrowserTools: (getSession: () => unknown, getConversationId: () => string) => ToolDefinition[];
+      createBrowserTools: (getSession: () => unknown) => ToolDefinition[];
       BrowserSession: new (sessionId: string, cfg?: Record<string, unknown>) => unknown;
     };
     try {
@@ -1193,7 +1205,6 @@ export class AgentHarness {
 
     const tools = browserMod.createBrowserTools(
       () => session,
-      () => this._currentRunConversationId ?? "__default__",
     );
     for (const tool of tools) {
       if (this.isToolEnabled(tool.name)) {
@@ -1202,10 +1213,6 @@ export class AgentHarness {
     }
   }
 
-  /** Conversation ID of the currently executing run (set during run, cleared after). */
-  private _currentRunConversationId?: string;
-  /** Owner ID of the currently executing run (used by subagent tools). */
-  private _currentRunOwnerId?: string;
 
   get browserSession(): unknown {
     return this._browserSession;
@@ -1353,13 +1360,6 @@ export class AgentHarness {
     await this.refreshAgentIfChanged();
     await this.refreshSkillsIfChanged();
 
-    // Track which conversation/owner this run belongs to so browser & subagent tools resolve correctly
-    this._currentRunConversationId = input.conversationId;
-    const ownerParam = input.parameters?.__ownerId;
-    if (typeof ownerParam === "string") {
-      this._currentRunOwnerId = ownerParam;
-    }
-
     let agent = this.parsedAgent as ParsedAgent;
     const runId = `run_${randomUUID()}`;
     const start = now();
@@ -1369,9 +1369,9 @@ export class AgentHarness {
       ? 0 // no hard timeout in development unless explicitly configured
       : (configuredTimeout ?? 300) * 1000;
     const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
-    const softDeadlineMs = platformMaxDurationSec > 0
-      ? platformMaxDurationSec * 800
-      : 0;
+    const softDeadlineMs = (input.disableSoftDeadline || platformMaxDurationSec <= 0)
+      ? 0
+      : platformMaxDurationSec * 800;
     const messages: Message[] = [...(input.messages ?? [])];
     const inputMessageCount = messages.length;
     const events: AgentEvent[] = [];
@@ -1525,6 +1525,18 @@ ${boundedMainMemory.trim()}`
           metadata: { timestamp: now(), id: randomUUID() },
         });
       }
+    } else {
+      // Continuation run (no explicit task). Some providers (Anthropic) require
+      // the conversation to end with a user message. Inject a transient signal
+      // that is sent to the LLM but never persisted to the conversation store.
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role !== "user") {
+        messages.push({
+          role: "user",
+          content: "[System: Your previous turn was interrupted by a time limit. Continue from where you left off — do NOT repeat what you already said. Proceed directly with the next action or tool call.]",
+          metadata: { timestamp: now(), id: randomUUID() },
+        });
+      }
     }
 
     let responseText = "";
@@ -1561,6 +1573,7 @@ ${boundedMainMemory.trim()}`
             tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
             duration: now() - start,
             continuation: true,
+            continuationMessages: [...messages],
             maxSteps,
           };
           yield pushEvent({ type: "run:completed", runId, result });
@@ -1711,6 +1724,9 @@ ${boundedMainMemory.trim()}`
             } catch {
               // Not JSON, treat as regular assistant text.
             }
+            if (!assistantText || assistantText.trim().length === 0) {
+              return [];
+            }
             return [{ role: "assistant" as const, content: assistantText }];
           }
 
@@ -2387,6 +2403,7 @@ ${boundedMainMemory.trim()}`
         tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
         duration: now() - start,
         continuation: true,
+        continuationMessages: [...messages],
         maxSteps,
       };
       yield pushEvent({ type: "run:completed", runId, result });

package/src/kv-store.ts

@@ -0,0 +1,216 @@
+import type { StateConfig } from "./state.js";
+
+/**
+ * Minimal raw key-value interface shared by MemoryStore, TodoStore, and any
+ * future stores that sit on top of the same user-configured backend.
+ */
+export interface RawKVStore {
+  get(key: string): Promise<string | undefined>;
+  set(key: string, value: string): Promise<void>;
+  setWithTtl(key: string, value: string, ttlSeconds: number): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Upstash
+// ---------------------------------------------------------------------------
+
+class UpstashKVStore implements RawKVStore {
+  private readonly baseUrl: string;
+  private readonly token: string;
+
+  constructor(baseUrl: string, token: string) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.token = token;
+  }
+
+  private headers(): HeadersInit {
+    return { Authorization: `Bearer ${this.token}`, "Content-Type": "application/json" };
+  }
+
+  async get(key: string): Promise<string | undefined> {
+    const response = await fetch(`${this.baseUrl}/get/${encodeURIComponent(key)}`, {
+      method: "POST",
+      headers: this.headers(),
+    });
+    if (!response.ok) return undefined;
+    const payload = (await response.json()) as { result?: string | null };
+    return payload.result ?? undefined;
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(["SET", key, value]),
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      console.error(`[kv][upstash] SET failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+  }
+
+  async setWithTtl(key: string, value: string, ttl: number): Promise<void> {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(["SETEX", key, Math.max(1, ttl), value]),
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      console.error(`[kv][upstash] SETEX failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Redis
+// ---------------------------------------------------------------------------
+
+class RedisKVStore implements RawKVStore {
+  private readonly clientPromise: Promise<
+    | {
+        get: (key: string) => Promise<string | null>;
+        set: (key: string, value: string, options?: { EX?: number }) => Promise<unknown>;
+      }
+    | undefined
+  >;
+
+  constructor(url: string) {
+    this.clientPromise = (async () => {
+      try {
+        const redisModule = (await import("redis")) as unknown as {
+          createClient: (args: { url: string }) => {
+            connect: () => Promise<unknown>;
+            get: (key: string) => Promise<string | null>;
+            set: (key: string, value: string, options?: { EX?: number }) => Promise<unknown>;
+          };
+        };
+        const client = redisModule.createClient({ url });
+        await client.connect();
+        return client;
+      } catch {
+        return undefined;
+      }
+    })();
+  }
+
+  async get(key: string): Promise<string | undefined> {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("Redis unavailable");
+    const value = await client.get(key);
+    return value ?? undefined;
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("Redis unavailable");
+    await client.set(key, value);
+  }
+
+  async setWithTtl(key: string, value: string, ttl: number): Promise<void> {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("Redis unavailable");
+    await client.set(key, value, { EX: Math.max(1, ttl) });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// DynamoDB
+// ---------------------------------------------------------------------------
+
+class DynamoDbKVStore implements RawKVStore {
+  private readonly table: string;
+  private readonly clientPromise: Promise<
+    | {
+        send: (command: unknown) => Promise<unknown>;
+        GetItemCommand: new (input: unknown) => unknown;
+        PutItemCommand: new (input: unknown) => unknown;
+      }
+    | undefined
+  >;
+
+  constructor(table: string, region?: string) {
+    this.table = table;
+    this.clientPromise = (async () => {
+      try {
+        const module = (await import("@aws-sdk/client-dynamodb")) as {
+          DynamoDBClient: new (input: { region?: string }) => {
+            send: (command: unknown) => Promise<unknown>;
+          };
+          GetItemCommand: new (input: unknown) => unknown;
+          PutItemCommand: new (input: unknown) => unknown;
+        };
+        const client = new module.DynamoDBClient({ region });
+        return {
+          send: client.send.bind(client),
+          GetItemCommand: module.GetItemCommand,
+          PutItemCommand: module.PutItemCommand,
+        };
+      } catch {
+        return undefined;
+      }
+    })();
+  }
+
+  async get(key: string): Promise<string | undefined> {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("DynamoDB unavailable");
+    const result = (await client.send(
+      new client.GetItemCommand({ TableName: this.table, Key: { runId: { S: key } } }),
+    )) as { Item?: { value?: { S?: string } } };
+    return result.Item?.value?.S;
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("DynamoDB unavailable");
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: { runId: { S: key }, value: { S: value } },
+      }),
+    );
+  }
+
+  async setWithTtl(key: string, value: string, ttl: number): Promise<void> {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("DynamoDB unavailable");
+    const ttlEpoch = Math.floor(Date.now() / 1000) + Math.max(1, ttl);
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: { runId: { S: key }, value: { S: value }, ttl: { N: String(ttlEpoch) } },
+      }),
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory — resolves the user's storage config into a RawKVStore, or
+// undefined when the provider is "local" or "memory" (handled by callers).
+// ---------------------------------------------------------------------------
+
+export const createRawKVStore = (config?: StateConfig): RawKVStore | undefined => {
+  const provider = config?.provider ?? "local";
+
+  if (provider === "upstash") {
+    const urlEnv = config?.urlEnv ?? (process.env.UPSTASH_REDIS_REST_URL ? "UPSTASH_REDIS_REST_URL" : "KV_REST_API_URL");
+    const tokenEnv = config?.tokenEnv ?? (process.env.UPSTASH_REDIS_REST_TOKEN ? "UPSTASH_REDIS_REST_TOKEN" : "KV_REST_API_TOKEN");
+    const url = process.env[urlEnv] ?? "";
+    const token = process.env[tokenEnv] ?? "";
+    if (url && token) return new UpstashKVStore(url, token);
+  }
+
+  if (provider === "redis") {
+    const urlEnv = config?.urlEnv ?? "REDIS_URL";
+    const url = process.env[urlEnv] ?? "";
+    if (url) return new RedisKVStore(url);
+  }
+
+  if (provider === "dynamodb") {
+    const table = config?.table ?? process.env.PONCHO_DYNAMODB_TABLE ?? "";
+    if (table) return new DynamoDbKVStore(table, config?.region);
+  }
+
+  return undefined;
+};