agent-office 0.4.5 → 0.4.6

package/dist/cli.js

@@ -15,6 +15,9 @@ program
     .option("--port <port>", "Port to serve on", "7654")
     .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
     .option("--opencode-url <url>", "URL of the OpenCode server (default: http://127.0.0.1:4096)", process.env.OPENCODE_URL ?? "http://127.0.0.1:4096")
+    .option("--pi-vendor <vendor>", "PI coding vendor (e.g., xai, openai, anthropic). Required when using PI coding server.", process.env.PI_VENDOR)
+    .option("--pi-model <model>", "PI coding model name (e.g., grok-code-fast-1). Required when using PI coding server.", process.env.PI_MODEL)
+    .option("--pi-api-key <key>", "PI coding API key. Required when using PI coding server.", process.env.PI_API_KEY)
     .action(async (options) => {
     const { serve } = await import("./commands/serve.js");
     await serve(options);

package/dist/commands/serve.d.ts

@@ -5,6 +5,9 @@ interface ServeOptions {
     port: string;
     password?: string;
     opencodeUrl: string;
+    piVendor?: string;
+    piModel?: string;
+    piApiKey?: string;
 }
 export declare function serve(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/serve.js

@@ -1,6 +1,7 @@
 import { createPostgresqlStorage, createSqliteStorage } from "../db/index.js";
 import { runMigrations } from "../db/migrate.js";
 import { OpenCodeCodingServer } from "../lib/opencode-coding-server.js";
+import { PiCodingServer } from "../lib/pi-coding-server.js";
 import { createApp } from "../server/index.js";
 import { CronScheduler } from "../server/cron.js";
 export async function serve(options) {
@@ -39,9 +40,35 @@ export async function serve(options) {
         await storage.close();
         process.exit(1);
     }
-    // Init agentic coding server (OpenCode implementation)
-    const agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
-    console.log(`Connecting to OpenCode server at ${options.opencodeUrl}...`);
+    // Init agentic coding server
+    let agenticCodingServer;
+    const piVendor = options.piVendor;
+    const piModel = options.piModel;
+    const piApiKey = options.piApiKey;
+    const hasAllPiOptions = piVendor && piModel && piApiKey;
+    const hasSomePiOptions = piVendor || piModel || piApiKey;
+    if (hasAllPiOptions) {
+        // Use PI Coding Server
+        agenticCodingServer = new PiCodingServer(piVendor, piModel, piApiKey);
+        console.log(`Using PI coding server with ${piVendor} ${piModel}...`);
+    }
+    else if (hasSomePiOptions) {
+        // Partial PI options - error
+        console.error("Error: All PI coding options must be provided together: --pi-vendor, --pi-model, --pi-api-key");
+        console.error("  Or set environment variables: PI_VENDOR, PI_MODEL, PI_API_KEY");
+        await storage.close();
+        process.exit(1);
+    }
+    else {
+        // Use OpenCode Coding Server (default)
+        agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
+        if (options.opencodeUrl === "http://127.0.0.1:4096") {
+            console.log(`Connecting to default OpenCode server at ${options.opencodeUrl}...`);
+        }
+        else {
+            console.log(`Connecting to OpenCode server at ${options.opencodeUrl}...`);
+        }
+    }
     const serverUrl = `http://${options.host}:${port}`;
     // Create cron scheduler
     const cronScheduler = new CronScheduler();

package/dist/lib/pi-coding-server.d.ts

@@ -0,0 +1,20 @@
+import type { AgenticCodingServer, SessionMessage, AgentMode } from "./agentic-coding-server.js";
+export declare class PiCodingServer implements AgenticCodingServer {
+    private sessions;
+    private authStorage;
+    private modelRegistry;
+    private selectedModel;
+    private vendor;
+    private modelName;
+    constructor(vendor: string, model: string, apiKey: string);
+    /** Shared creation logic (no duplication) */
+    private createSessionInternal;
+    /** Fallback helper: returns cached session OR creates new one with the exact provided ID */
+    private ensureSession;
+    createSession(_title: string): Promise<string>;
+    deleteSession(sessionID: string): Promise<void>;
+    sendMessage(sessionID: string, text: string, agent: string, system: string): Promise<void>;
+    getMessages(sessionID: string, limit?: number): Promise<SessionMessage[]>;
+    revertSession(sessionID: string, messageID: string): Promise<void>;
+    getAgentModes(): Promise<AgentMode[]>;
+}

package/dist/lib/pi-coding-server.js

@@ -0,0 +1,162 @@
+import { createAgentSession, SessionManager, AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { getModel } from "@mariozechner/pi-ai";
+import crypto from "crypto";
+import path from "path";
+import fs from "fs/promises";
+export class PiCodingServer {
+    sessions = new Map();
+    authStorage;
+    modelRegistry;
+    selectedModel;
+    vendor;
+    modelName;
+    constructor(vendor, model, apiKey) {
+        if (!vendor || !model || !apiKey?.trim()) {
+            throw new Error("vendor, model, and apiKey are all required and must not be empty");
+        }
+        this.vendor = vendor.trim().toLowerCase();
+        this.modelName = model.trim();
+        this.authStorage = AuthStorage.create();
+        this.authStorage.setRuntimeApiKey(this.vendor, apiKey);
+        this.modelRegistry = new ModelRegistry(this.authStorage);
+        this.selectedModel = getModel(this.vendor, this.modelName);
+        if (!this.selectedModel) {
+            throw new Error(`Model '${this.modelName}' not found for provider '${this.vendor}'. ` +
+                `Check spelling or run 'pi /model' in a terminal.`);
+        }
+    }
+    /** Shared creation logic (no duplication) */
+    async createSessionInternal(sessionID) {
+        const workspace = path.join(process.cwd(), "workspaces", sessionID);
+        await fs.mkdir(workspace, { recursive: true });
+        const sessionManager = SessionManager.create(workspace);
+        const { session } = await createAgentSession({
+            cwd: workspace,
+            model: this.selectedModel,
+            thinkingLevel: "medium",
+            sessionManager,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+        });
+        return session;
+    }
+    /** Fallback helper: returns cached session OR creates new one with the exact provided ID */
+    async ensureSession(sessionID) {
+        let session = this.sessions.get(sessionID);
+        if (!session) {
+            session = await this.createSessionInternal(sessionID);
+            this.sessions.set(sessionID, session);
+        }
+        return session;
+    }
+    async createSession(_title) {
+        const sessionID = crypto.randomUUID();
+        const session = await this.createSessionInternal(sessionID);
+        this.sessions.set(sessionID, session);
+        return sessionID;
+    }
+    async deleteSession(sessionID) {
+        const session = this.sessions.get(sessionID);
+        if (session) {
+            session.dispose?.();
+            this.sessions.delete(sessionID);
+        }
+    }
+    async sendMessage(sessionID, text, agent, system) {
+        const session = await this.ensureSession(sessionID);
+        const prefix = agent ? `[Message from coworker ${agent}]: ` : "";
+        const message = `${prefix}${text}`;
+        // Set the system prompt if provided
+        if (system && system.trim()) {
+            session.agent.setSystemPrompt(system);
+        }
+        // Create a promise that resolves when the agent finishes processing
+        const completionPromise = new Promise((resolve) => {
+            const unsubscribe = session.subscribe((event) => {
+                if (event.type === "agent_end") {
+                    unsubscribe();
+                    resolve();
+                }
+            });
+            // Timeout after 5 minutes in case agent never finishes
+            setTimeout(() => {
+                unsubscribe();
+                resolve();
+            }, 5 * 60 * 1000);
+        });
+        // Send the prompt
+        await session.prompt(message);
+        // Wait for processing to complete
+        await completionPromise;
+    }
+    async getMessages(sessionID, limit = 100) {
+        const session = await this.ensureSession(sessionID);
+        const msgs = session.messages || [];
+        return msgs.slice(-limit).map((m) => {
+            let role = "assistant";
+            let parts = [];
+            if (m.role === "user") {
+                role = "user";
+                // User message content can be string or array
+                if (typeof m.content === "string") {
+                    parts = [{ type: "text", text: m.content }];
+                }
+                else if (Array.isArray(m.content)) {
+                    parts = m.content.map((c) => {
+                        if (c.type === "text")
+                            return { type: "text", text: c.text };
+                        return { type: c.type || "text", text: JSON.stringify(c) };
+                    });
+                }
+                else {
+                    parts = [{ type: "text", text: JSON.stringify(m.content) }];
+                }
+            }
+            else if (m.role === "assistant") {
+                role = "assistant";
+                // Assistant message content is always an array of TextContent | ThinkingContent | ToolCall
+                if (Array.isArray(m.content)) {
+                    parts = m.content.map((c) => {
+                        if (c.type === "text")
+                            return { type: "text", text: c.text };
+                        if (c.type === "thinking")
+                            return { type: "thinking", text: c.thinking };
+                        if (c.type === "toolCall")
+                            return { type: "toolCall", text: `[Tool: ${c.name}]` };
+                        return { type: c.type || "text", text: JSON.stringify(c) };
+                    });
+                }
+                else if (typeof m.content === "string") {
+                    parts = [{ type: "text", text: m.content }];
+                }
+            }
+            else {
+                // toolResult or other custom types
+                parts = [{ type: "text", text: JSON.stringify(m.content) }];
+            }
+            return {
+                id: m.id || m.entryId || crypto.randomUUID(),
+                role,
+                parts,
+            };
+        });
+    }
+    async revertSession(sessionID, messageID) {
+        const session = await this.ensureSession(sessionID);
+        try {
+            await session.navigateTree(messageID, { summarize: true });
+        }
+        catch (err) {
+            // Graceful: new/empty sessions can't revert → still succeed the call
+        }
+    }
+    async getAgentModes() {
+        return [
+            {
+                name: "coworker",
+                description: `${this.vendor.toUpperCase()} ${this.modelName} – fast agentic coding coworker`,
+                model: this.modelName,
+            },
+        ];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",
@@ -33,6 +33,8 @@
   },
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
+    "@mariozechner/pi-ai": "^0.54.2",
+    "@mariozechner/pi-coding-agent": "^0.54.2",
     "@opencode-ai/sdk": "^1.2.10",
     "agent-office": "^0.2.2",
     "better-sqlite3": "^12.6.2",