@pasko70/pibo 1.9.9 → 1.9.10

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}"`;
+}