@pasko70/pibo 1.9.9 → 1.9.11

package/context/pibo-system-prompt.md

@@ -1,78 +1,78 @@
-# Agent System
-
-You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
-
-## Tools
-
-Available tools:
-{{availableTools}}
-
-In addition to the tools above, you may have access to other custom tools depending on the project.
-
-## Guidelines
-
-{{guidelines}}
-
-Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
-
-**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
-
-## 1. Think Before Coding
-
-**Don't assume. Don't hide confusion. Surface tradeoffs.**
-
-Before implementing:
-- State your assumptions explicitly. If uncertain, ask.
-- If multiple interpretations exist, present them - don't pick silently.
-- If a simpler approach exists, say so. Push back when warranted.
-- If something is unclear, stop. Name what's confusing. Ask.
-
-## 2. Simplicity First
-
-**Minimum code that solves the problem. Nothing speculative.**
-
-- No features beyond what was asked.
-- No abstractions for single-use code.
-- No "flexibility" or "configurability" that wasn't requested.
-- No error handling for impossible scenarios.
-- If you write 200 lines and it could be 50, rewrite it.
-
-Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
-
-## 3. Surgical Changes
-
-**Touch only what you must. Clean up only your own mess.**
-
-When editing existing code:
-- Don't "improve" adjacent code, comments, or formatting.
-- Don't refactor things that aren't broken.
-- Match existing style, even if you'd do it differently.
-- If you notice unrelated dead code, mention it - don't delete it.
-
-When your changes create orphans:
-- Remove imports/variables/functions that YOUR changes made unused.
-- Don't remove pre-existing dead code unless asked.
-
-The test: Every changed line should trace directly to the user's request.
-
-## 4. Goal-Driven Execution
-
-**Define success criteria. Loop until verified.**
-
-Transform tasks into verifiable goals:
-- "Add validation" → "Write tests for invalid inputs, then make them pass"
-- "Fix the bug" → "Write a test that reproduces it, then make it pass"
-- "Refactor X" → "Ensure tests pass before and after"
-
-For multi-step tasks, state a brief plan:
-```
-1. [Step] → verify: [check]
-2. [Step] → verify: [check]
-3. [Step] → verify: [check]
-```
-
-Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
-
----
-
+# Agent System
+
+You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+
+## Tools
+
+Available tools:
+{{availableTools}}
+
+In addition to the tools above, you may have access to other custom tools depending on the project.
+
+## Guidelines
+
+{{guidelines}}
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
 **These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.

package/dist/api/simple-agent-api.js

@@ -0,0 +1,136 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { PiboWebHttpError, readJsonBody, responseJson } from "../web/http.js";
+const DEFAULT_SEND_MESSAGE_TIMEOUT_MS = 10 * 60 * 1000;
+function configuredApiKey(options) {
+    return options.apiKey ?? process.env.PIBO_SIMPLE_API_KEY;
+}
+function safeEqual(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    if (leftBuffer.length !== rightBuffer.length)
+        return false;
+    return timingSafeEqual(leftBuffer, rightBuffer);
+}
+function decodeBasicAuthCredential(value) {
+    const match = value.match(/^Basic\s+(.+)$/i);
+    if (!match)
+        return [];
+    try {
+        const decoded = Buffer.from(match[1] ?? "", "base64").toString("utf8");
+        return decoded.split(":").map((part) => part.trim()).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function requestApiKeyCandidates(request) {
+    const candidates = [];
+    const add = (value) => {
+        let trimmed = value?.trim();
+        if (!trimmed)
+            return;
+        candidates.push(trimmed);
+        while (/^(Bearer|Token)\s+/i.test(trimmed)) {
+            trimmed = trimmed.replace(/^(Bearer|Token)\s+/i, "").trim();
+            if (trimmed)
+                candidates.push(trimmed);
+        }
+    };
+    add(request.headers.get("x-api-key"));
+    add(request.headers.get("api-key"));
+    const authorization = request.headers.get("authorization")?.trim();
+    add(authorization);
+    for (const credential of decodeBasicAuthCredential(authorization ?? ""))
+        add(credential);
+    return candidates;
+}
+function requireApiKey(request, options) {
+    const expected = configuredApiKey(options);
+    if (!expected)
+        throw new PiboWebHttpError("Simple agent API key is not configured", 503);
+    const candidates = requestApiKeyCandidates(request);
+    if (!candidates.some((candidate) => safeEqual(candidate, expected))) {
+        throw new PiboWebHttpError("Invalid API key", 401);
+    }
+}
+function requireString(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new PiboWebHttpError(`${name} is required`, 400);
+    }
+    return value;
+}
+function parseSendMessageBody(body) {
+    return {
+        sessionId: requireString(body.sessionId, "sessionId"),
+        message: requireString(body.message, "message"),
+    };
+}
+function awaitAgentMessage(context, input) {
+    return new Promise((resolve, reject) => {
+        let lastAssistantMessage = "";
+        let settled = false;
+        let unsubscribe;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            unsubscribe?.();
+            callback();
+        };
+        const timeout = setTimeout(() => {
+            finish(() => reject(new PiboWebHttpError("Timed out waiting for agent response", 504)));
+        }, input.timeoutMs);
+        unsubscribe = context.subscribe((event) => {
+            if (event.piboSessionId !== input.sessionId || !("eventId" in event) || event.eventId !== input.eventId)
+                return;
+            if (event.type === "assistant_message") {
+                lastAssistantMessage = event.text;
+                return;
+            }
+            if (event.type === "session_error") {
+                finish(() => reject(new PiboWebHttpError(event.error, 500)));
+                return;
+            }
+            if (event.type === "message_finished") {
+                finish(() => resolve({ eventId: input.eventId, sessionId: input.sessionId, message: lastAssistantMessage }));
+            }
+        });
+    });
+}
+async function handleSendMessage(request, context, options) {
+    requireApiKey(request, options);
+    const input = parseSendMessageBody(await readJsonBody(request));
+    if (!context.getSession(input.sessionId)) {
+        throw new PiboWebHttpError("Unknown sessionId", 404);
+    }
+    const eventId = randomUUID();
+    const responsePromise = awaitAgentMessage(context, {
+        sessionId: input.sessionId,
+        eventId,
+        timeoutMs: options.timeoutMs ?? DEFAULT_SEND_MESSAGE_TIMEOUT_MS,
+    });
+    await context.emit({
+        type: "message",
+        piboSessionId: input.sessionId,
+        id: eventId,
+        text: input.message,
+        source: "service",
+    });
+    return responseJson(await responsePromise);
+}
+export async function handleSimpleAgentApiRequest(request, context, options = {}) {
+    const url = new URL(request.url);
+    if (url.pathname === "/api/health") {
+        if (request.method !== "GET" && request.method !== "HEAD") {
+            return responseJson({ error: "Method not allowed" }, { status: 405, headers: { allow: "GET, HEAD" } });
+        }
+        return responseJson({ status: "ok" });
+    }
+    if (url.pathname !== "/api/send-message")
+        return undefined;
+    if (request.method !== "POST") {
+        return responseJson({ error: "Method not allowed" }, { status: 405, headers: { allow: "POST" } });
+    }
+    return handleSendMessage(request, context, options);
+}

package/dist/app-context.js

@@ -0,0 +1,4 @@
+export const PIBO_APP_CONTEXT = Object.freeze({
+    kind: "app-context",
+    id: "app",
+});

package/dist/apps/chat/agent-profiles.js

@@ -0,0 +1,70 @@
+import { InitialSessionContextBuilder } from "../../core/profiles.js";
+export function createCustomAgentProfileDefinition(agent, options = {}) {
+    const shouldWarnMissingReferences = options.missingReferenceMode !== "silent";
+    return {
+        name: agent.profileName,
+        aliases: uniqueAliases([agent.id, `custom-agent:${agent.id}`, ...agent.profileAliases], agent.profileName),
+        description: agent.description || agent.displayName,
+        create(context) {
+            const builder = new InitialSessionContextBuilder(agent.profileName)
+                .withBuiltinTools(agent.builtinTools)
+                .withBuiltinToolNames(agent.builtinToolNames)
+                .withAutoContextFiles(agent.autoContextFiles)
+                .withMcpServers(agent.mcpServers)
+                .withPiPackages(agent.piPackages.map((id) => ({ id })))
+                .withToolPackages({ runControl: agent.runControl });
+            if (agent.mainModel)
+                builder.withMainModel(agent.mainModel);
+            if (agent.subagentModel)
+                builder.withSubagentModel(agent.subagentModel);
+            if (agent.thinkingLevel)
+                builder.withThinkingLevel(agent.thinkingLevel);
+            if (agent.mainThinkingLevel)
+                builder.withMainThinkingLevel(agent.mainThinkingLevel);
+            if (agent.subagentThinkingLevel)
+                builder.withSubagentThinkingLevel(agent.subagentThinkingLevel);
+            if (agent.fast !== undefined)
+                builder.withFastMode(agent.fast);
+            if (agent.mainFast !== undefined)
+                builder.withMainFastMode(agent.mainFast);
+            if (agent.subagentFast !== undefined)
+                builder.withSubagentFastMode(agent.subagentFast);
+            for (const skillName of agent.skills) {
+                try {
+                    builder.addSkill(context.getSkill(skillName));
+                }
+                catch (error) {
+                    if (!isUnknownSkillError(error, skillName))
+                        throw error;
+                    if (shouldWarnMissingReferences)
+                        console.warn(`Skipping unknown skill "${skillName}" for custom agent "${agent.profileName}"`);
+                }
+            }
+            for (const contextFileKey of agent.contextFiles) {
+                try {
+                    builder.addContextFile(context.getContextFile(contextFileKey));
+                }
+                catch (error) {
+                    if (!isUnknownContextFileError(error, contextFileKey))
+                        throw error;
+                    if (shouldWarnMissingReferences)
+                        console.warn(`Skipping unknown context file "${contextFileKey}" for custom agent "${agent.profileName}"`);
+                }
+            }
+            for (const toolName of agent.nativeTools)
+                builder.addTool(context.getTool(toolName));
+            for (const subagent of agent.subagents)
+                builder.addSubagent(subagent);
+            return builder.createSession();
+        },
+    };
+}
+function uniqueAliases(aliases, profileName) {
+    return [...new Set(aliases.filter((alias) => alias && alias !== profileName))];
+}
+function isUnknownContextFileError(error, contextFileKey) {
+    return error instanceof Error && error.message === `Unknown context file "${contextFileKey}"`;
+}
+function isUnknownSkillError(error, skillName) {
+    return error instanceof Error && error.message === `Unknown skill "${skillName}"`;
+}