@sheepbun/yips 0.1.1 → 0.1.47

package/dist/gateway/adapters/whatsapp.js

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WhatsAppAdapter = void 0;
-const formatting_1 = require("#gateway/adapters/formatting");
-const DEFAULT_API_BASE_URL = "https://graph.facebook.com";
-const DEFAULT_API_VERSION = "v21.0";
-const DEFAULT_MAX_MESSAGE_LENGTH = 4000;
-function isObject(value) {
-    return typeof value === "object" && value !== null;
-}
-function parseTimestamp(value) {
-    if (!value) {
-        return undefined;
-    }
-    const seconds = Number.parseInt(value, 10);
-    if (!Number.isFinite(seconds)) {
-        return undefined;
-    }
-    return new Date(seconds * 1000);
-}
-function findContactByWaId(contacts, waId) {
-    if (!contacts || contacts.length === 0) {
-        return undefined;
-    }
-    return contacts.find((contact) => contact.wa_id === waId);
-}
-function toInboundMessage(message, value, entryId) {
-    if (message.type !== "text") {
-        return null;
-    }
-    const senderId = message.from;
-    const text = message.text?.body;
-    if (typeof senderId !== "string" || typeof text !== "string") {
-        return null;
-    }
-    const contact = findContactByWaId(value.contacts, senderId);
-    return {
-        platform: "whatsapp",
-        senderId,
-        channelId: value.metadata?.phone_number_id,
-        text,
-        messageId: message.id,
-        timestamp: parseTimestamp(message.timestamp),
-        metadata: {
-            waId: contact?.wa_id ?? senderId,
-            profileName: contact?.profile?.name,
-            displayPhoneNumber: value.metadata?.display_phone_number,
-            phoneNumberId: value.metadata?.phone_number_id,
-            entryId
-        }
-    };
-}
-function parseInboundMessages(payload) {
-    if (!isObject(payload)) {
-        return [];
-    }
-    const envelope = payload;
-    if (!Array.isArray(envelope.entry)) {
-        return [];
-    }
-    const messages = [];
-    for (const entry of envelope.entry) {
-        if (!Array.isArray(entry.changes)) {
-            continue;
-        }
-        for (const change of entry.changes) {
-            const value = change.value;
-            if (!value || !Array.isArray(value.messages)) {
-                continue;
-            }
-            for (const message of value.messages) {
-                const inbound = toInboundMessage(message, value, entry.id);
-                if (inbound) {
-                    messages.push(inbound);
-                }
-            }
-        }
-    }
-    return messages;
-}
-class WhatsAppAdapter {
-    platform = "whatsapp";
-    accessToken;
-    phoneNumberId;
-    apiBaseUrl;
-    apiVersion;
-    maxMessageLength;
-    constructor(options) {
-        this.accessToken = options.accessToken.trim();
-        this.phoneNumberId = options.phoneNumberId.trim();
-        this.apiBaseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).trim().replace(/\/+$/, "");
-        this.apiVersion = (options.apiVersion ?? DEFAULT_API_VERSION).trim();
-        this.maxMessageLength = Math.max(1, Math.trunc(options.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH));
-    }
-    parseInbound(payload) {
-        return parseInboundMessages(payload);
-    }
-    formatOutbound(context, response) {
-        const normalizedText = (0, formatting_1.normalizeOutboundText)(response.text);
-        const chunks = (0, formatting_1.chunkOutboundText)(normalizedText, this.maxMessageLength);
-        if (chunks.length === 0) {
-            return null;
-        }
-        const requests = chunks.map((chunk) => ({
-            method: "POST",
-            endpoint: `${this.apiBaseUrl}/${this.apiVersion}/${this.phoneNumberId}/messages`,
-            headers: {
-                authorization: `Bearer ${this.accessToken}`,
-                "content-type": "application/json"
-            },
-            body: {
-                messaging_product: "whatsapp",
-                recipient_type: "individual",
-                to: context.message.senderId,
-                type: "text",
-                text: {
-                    body: chunk
-                }
-            }
-        }));
-        return requests.length === 1 ? (requests[0] ?? null) : requests;
-    }
-}
-exports.WhatsAppAdapter = WhatsAppAdapter;

package/dist/gateway/auth-policy.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayAuthPolicy = void 0;
-function toSenderKey(message) {
-    return `${message.platform}:${message.senderId}`;
-}
-function parseAuthCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/auth")) {
-        return null;
-    }
-    const parts = trimmed.split(/\s+/);
-    if (parts[0] !== "/auth") {
-        return null;
-    }
-    return parts[1] ?? "";
-}
-class GatewayAuthPolicy {
-    allowedSenderIds;
-    passphrase;
-    authenticatedSenders = new Set();
-    constructor(options) {
-        this.allowedSenderIds =
-            options.allowedSenderIds && options.allowedSenderIds.length > 0
-                ? new Set(options.allowedSenderIds)
-                : null;
-        this.passphrase = options.passphrase?.trim() ? options.passphrase.trim() : null;
-    }
-    evaluate(message) {
-        if (this.allowedSenderIds && !this.allowedSenderIds.has(message.senderId)) {
-            return {
-                type: "unauthorized",
-                reason: "sender_not_allowed"
-            };
-        }
-        if (!this.passphrase) {
-            return {
-                type: "authorized"
-            };
-        }
-        const senderKey = toSenderKey(message);
-        if (this.authenticatedSenders.has(senderKey)) {
-            return {
-                type: "authorized"
-            };
-        }
-        const authAttempt = parseAuthCommand(message.text);
-        if (authAttempt === null) {
-            return {
-                type: "unauthorized",
-                reason: "passphrase_required"
-            };
-        }
-        if (authAttempt !== this.passphrase) {
-            return {
-                type: "unauthorized",
-                reason: "passphrase_invalid"
-            };
-        }
-        this.authenticatedSenders.add(senderKey);
-        return {
-            type: "authenticated"
-        };
-    }
-}
-exports.GatewayAuthPolicy = GatewayAuthPolicy;

package/dist/gateway/core.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayCore = void 0;
-const auth_policy_1 = require("#gateway/auth-policy");
-const message_router_1 = require("#gateway/message-router");
-const rate_limiter_1 = require("#gateway/rate-limiter");
-const session_manager_1 = require("#gateway/session-manager");
-class GatewayCore {
-    authPolicy;
-    unauthorizedMessage;
-    rateLimiter;
-    sessionManager;
-    handleMessageFn;
-    constructor(options) {
-        this.authPolicy = new auth_policy_1.GatewayAuthPolicy({
-            allowedSenderIds: options.allowedSenderIds,
-            passphrase: options.passphrase
-        });
-        this.unauthorizedMessage =
-            options.unauthorizedMessage ??
-                "Access denied. Authenticate with /auth <passphrase> or contact the administrator.";
-        this.rateLimiter =
-            options.rateLimiter ??
-                new rate_limiter_1.GatewayRateLimiter({
-                    maxMessages: 20,
-                    windowMs: 60_000
-                });
-        this.sessionManager = options.sessionManager ?? new session_manager_1.GatewaySessionManager();
-        this.handleMessageFn = options.handleMessage;
-    }
-    async dispatch(message) {
-        const normalizedMessage = (0, message_router_1.normalizeIncomingMessage)(message);
-        const validationError = (0, message_router_1.validateIncomingMessage)(normalizedMessage);
-        if (validationError) {
-            return {
-                status: "invalid",
-                reason: validationError
-            };
-        }
-        const authDecision = this.authPolicy.evaluate(normalizedMessage);
-        if (authDecision.type === "authenticated") {
-            return {
-                status: "authenticated",
-                response: {
-                    text: "Authentication successful. You can now send messages."
-                }
-            };
-        }
-        if (authDecision.type === "unauthorized") {
-            return {
-                status: "unauthorized",
-                reason: authDecision.reason,
-                response: {
-                    text: this.unauthorizedMessage
-                }
-            };
-        }
-        const rate = this.rateLimiter.check(normalizedMessage.senderId);
-        if (!rate.allowed) {
-            return {
-                status: "rate_limited",
-                reason: "rate_limit_exceeded",
-                retryAfterMs: rate.retryAfterMs
-            };
-        }
-        const session = this.sessionManager.getOrCreateSession(normalizedMessage);
-        const response = await this.handleMessageFn({
-            message: normalizedMessage,
-            session
-        });
-        return {
-            status: "ok",
-            sessionId: session.id,
-            response
-        };
-    }
-    listSessions() {
-        return this.sessionManager.listSessions();
-    }
-    pruneIdleSessions(maxIdleMs) {
-        return this.sessionManager.pruneIdleSessions(maxIdleMs);
-    }
-    pruneRateLimiterState() {
-        return this.rateLimiter.pruneStaleCounters();
-    }
-}
-exports.GatewayCore = GatewayCore;

package/dist/gateway/headless-conductor.js

@@ -1,328 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayHeadlessConductor = void 0;
-exports.createGatewayHeadlessMessageHandler = createGatewayHeadlessMessageHandler;
-const conductor_1 = require("#agent/conductor");
-const code_context_1 = require("#agent/context/code-context");
-const session_store_1 = require("#agent/context/session-store");
-const skills_1 = require("#agent/skills/skills");
-const tool_executor_1 = require("#agent/tools/tool-executor");
-const tool_safety_1 = require("#agent/tools/tool-safety");
-const llama_server_1 = require("#llm/llama-server");
-const llama_client_1 = require("#llm/llama-client");
-const token_counter_1 = require("#llm/token-counter");
-const vt_session_1 = require("#ui/input/vt-session");
-const UNSUPPORTED_BACKEND_RESPONSE = "Gateway headless mode currently supports backend 'llamacpp' only.";
-const AUTO_DENY_OUTPUT = "Action denied by gateway safety policy.";
-function composeChatRequestMessages(history, codeContextMessage) {
-    if (!codeContextMessage) {
-        return history;
-    }
-    return [{ role: "system", content: codeContextMessage }, ...history];
-}
-function buildSubagentScopeMessage(call) {
-    const lines = [
-        "Subagent scope:",
-        `Task: ${call.task}`,
-        call.context ? `Context: ${call.context}` : null,
-        call.allowedTools
-            ? `Allowed tools: ${call.allowedTools.length > 0 ? call.allowedTools.join(", ") : "(none)"}`
-            : "Allowed tools: all available tools",
-        "Stay focused on the delegated scope and return concise findings."
-    ].filter((line) => line !== null);
-    return lines.join("\n");
-}
-function assessToolCallRisk(call, workingZone) {
-    if (call.name === "run_command") {
-        const command = typeof call.arguments["command"] === "string" ? call.arguments["command"] : "";
-        const cwdArg = typeof call.arguments["cwd"] === "string" ? call.arguments["cwd"] : ".";
-        const resolvedCwd = (0, tool_safety_1.resolveToolPath)(cwdArg, workingZone);
-        return (0, tool_safety_1.assessCommandRisk)(command, resolvedCwd, workingZone);
-    }
-    const pathArg = typeof call.arguments["path"] === "string" ? call.arguments["path"] : ".";
-    return (0, tool_safety_1.assessPathRisk)(pathArg, workingZone);
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-const DEFAULT_DEPS = {
-    createLlamaClient: (config) => new llama_client_1.LlamaClient({
-        baseUrl: config.llamaBaseUrl,
-        model: config.model
-    }),
-    ensureReady: llama_server_1.ensureLlamaReady,
-    formatStartupFailure: llama_server_1.formatLlamaStartupFailure,
-    runConductor: conductor_1.runConductorTurn,
-    executeTool: tool_executor_1.executeToolCall,
-    executeSkill: skills_1.executeSkillCall,
-    createVtSession: () => new vt_session_1.VirtualTerminalSession(),
-    loadCodeContext: code_context_1.loadCodeContext,
-    toCodeContextSystemMessage: code_context_1.toCodeContextSystemMessage,
-    createSessionFile: session_store_1.createSessionFileFromHistory,
-    writeSessionFile: session_store_1.writeSessionFile,
-    estimateCompletionTokens: (text) => (0, token_counter_1.estimateConversationTokens)([{ content: text }]),
-    estimateHistoryTokens: (history) => (0, token_counter_1.estimateConversationTokens)(history)
-};
-class GatewayHeadlessConductor {
-    config;
-    gatewayBackend;
-    username;
-    workingDirectory;
-    maxRounds;
-    deps;
-    sessionStates = new Map();
-    llamaClient;
-    vtSession;
-    codeContextMessage = null;
-    constructor(options, deps = {}) {
-        this.config = options.config;
-        this.gatewayBackend = options.gatewayBackend ?? this.config.backend;
-        this.username = options.username ?? "Gateway User";
-        this.workingDirectory = options.workingDirectory ?? process.cwd();
-        this.maxRounds = options.maxRounds;
-        this.deps = { ...DEFAULT_DEPS, ...deps };
-        this.llamaClient = this.deps.createLlamaClient(this.config);
-        this.vtSession = this.deps.createVtSession();
-    }
-    async initialize() {
-        const loaded = await this.deps.loadCodeContext(this.workingDirectory);
-        if (!loaded) {
-            this.codeContextMessage = null;
-            return;
-        }
-        this.codeContextMessage = this.deps.toCodeContextSystemMessage(loaded);
-    }
-    async handleMessage(context) {
-        if (this.gatewayBackend !== "llamacpp") {
-            return {
-                text: `${UNSUPPORTED_BACKEND_RESPONSE} Configured backend: '${this.gatewayBackend}'.`
-            };
-        }
-        const state = this.getOrCreateSessionState(context);
-        state.history.push({ role: "user", content: context.message.text });
-        let latestAssistantText = "";
-        try {
-            await this.deps.runConductor({
-                history: state.history,
-                requestAssistant: async () => {
-                    const readiness = await this.deps.ensureReady(this.config);
-                    if (!readiness.ready) {
-                        throw new Error(readiness.failure
-                            ? this.deps.formatStartupFailure(readiness.failure, this.config)
-                            : "llama.cpp is unavailable.");
-                    }
-                    this.llamaClient.setModel(this.config.model);
-                    const requestMessages = composeChatRequestMessages(state.history, this.codeContextMessage);
-                    const result = await this.llamaClient.chat(requestMessages, this.config.model);
-                    return {
-                        text: result.text,
-                        rendered: false,
-                        totalTokens: result.usage?.totalTokens,
-                        completionTokens: result.usage?.completionTokens ?? this.deps.estimateCompletionTokens(result.text)
-                    };
-                },
-                executeToolCalls: async (toolCalls) => {
-                    const results = [];
-                    for (const call of toolCalls) {
-                        const risk = assessToolCallRisk(call, this.workingDirectory);
-                        if (risk.requiresConfirmation) {
-                            results.push({
-                                callId: call.id,
-                                tool: call.name,
-                                status: "denied",
-                                output: AUTO_DENY_OUTPUT
-                            });
-                            continue;
-                        }
-                        const result = await this.deps.executeTool(call, {
-                            workingDirectory: this.workingDirectory,
-                            vtSession: this.vtSession
-                        });
-                        results.push(result);
-                    }
-                    return results;
-                },
-                executeSkillCalls: async (skillCalls) => {
-                    const results = [];
-                    for (const call of skillCalls) {
-                        const result = await this.deps.executeSkill(call, {
-                            workingDirectory: this.workingDirectory,
-                            vtSession: this.vtSession
-                        });
-                        results.push(result);
-                    }
-                    return results;
-                },
-                executeSubagentCalls: async (subagentCalls) => {
-                    const results = [];
-                    for (const subagentCall of subagentCalls) {
-                        const scopedHistory = [
-                            { role: "system", content: buildSubagentScopeMessage(subagentCall) },
-                            { role: "user", content: subagentCall.task }
-                        ];
-                        const allowedTools = subagentCall.allowedTools !== undefined ? new Set(subagentCall.allowedTools) : null;
-                        try {
-                            const turn = await this.deps.runConductor({
-                                history: scopedHistory,
-                                requestAssistant: async () => {
-                                    const readiness = await this.deps.ensureReady(this.config);
-                                    if (!readiness.ready) {
-                                        throw new Error(readiness.failure
-                                            ? this.deps.formatStartupFailure(readiness.failure, this.config)
-                                            : "llama.cpp is unavailable.");
-                                    }
-                                    this.llamaClient.setModel(this.config.model);
-                                    const requestMessages = composeChatRequestMessages(scopedHistory, null);
-                                    const result = await this.llamaClient.chat(requestMessages, this.config.model);
-                                    return {
-                                        text: result.text,
-                                        rendered: false,
-                                        totalTokens: result.usage?.totalTokens,
-                                        completionTokens: result.usage?.completionTokens ??
-                                            this.deps.estimateCompletionTokens(result.text)
-                                    };
-                                },
-                                executeToolCalls: async (toolCalls) => {
-                                    const denied = [];
-                                    const permitted = [];
-                                    for (const call of toolCalls) {
-                                        if (allowedTools && !allowedTools.has(call.name)) {
-                                            denied.push({
-                                                callId: call.id,
-                                                tool: call.name,
-                                                status: "denied",
-                                                output: `Tool '${call.name}' is not allowed for subagent ${subagentCall.id}.`
-                                            });
-                                            continue;
-                                        }
-                                        const risk = assessToolCallRisk(call, this.workingDirectory);
-                                        if (risk.requiresConfirmation) {
-                                            denied.push({
-                                                callId: call.id,
-                                                tool: call.name,
-                                                status: "denied",
-                                                output: AUTO_DENY_OUTPUT
-                                            });
-                                            continue;
-                                        }
-                                        permitted.push(call);
-                                    }
-                                    const executed = [];
-                                    for (const call of permitted) {
-                                        const result = await this.deps.executeTool(call, {
-                                            workingDirectory: this.workingDirectory,
-                                            vtSession: this.vtSession
-                                        });
-                                        executed.push(result);
-                                    }
-                                    return [...denied, ...executed];
-                                },
-                                executeSkillCalls: async (skillCalls) => {
-                                    const skillResults = [];
-                                    for (const call of skillCalls) {
-                                        const result = await this.deps.executeSkill(call, {
-                                            workingDirectory: this.workingDirectory,
-                                            vtSession: this.vtSession
-                                        });
-                                        skillResults.push(result);
-                                    }
-                                    return skillResults;
-                                },
-                                onAssistantText: () => {
-                                    // Subagent responses are returned in metadata only.
-                                },
-                                onWarning: () => {
-                                    // Warnings are intentionally omitted from outbound gateway text.
-                                },
-                                estimateCompletionTokens: this.deps.estimateCompletionTokens,
-                                estimateHistoryTokens: this.deps.estimateHistoryTokens,
-                                computeTokensPerSecond: () => null,
-                                maxRounds: subagentCall.maxRounds ?? 4
-                            });
-                            const latest = [...scopedHistory]
-                                .reverse()
-                                .find((entry) => entry.role === "assistant")?.content;
-                            results.push({
-                                callId: subagentCall.id,
-                                status: turn.finished ? "ok" : "timeout",
-                                output: latest ?? "Subagent completed without assistant output.",
-                                metadata: {
-                                    rounds: turn.rounds
-                                }
-                            });
-                        }
-                        catch (error) {
-                            results.push({
-                                callId: subagentCall.id,
-                                status: "error",
-                                output: `Subagent failed: ${toErrorMessage(error)}`
-                            });
-                        }
-                    }
-                    return results;
-                },
-                onAssistantText: (assistantText) => {
-                    latestAssistantText = assistantText;
-                },
-                onWarning: () => {
-                    // Warnings are intentionally omitted from outbound gateway text.
-                },
-                estimateCompletionTokens: this.deps.estimateCompletionTokens,
-                estimateHistoryTokens: this.deps.estimateHistoryTokens,
-                computeTokensPerSecond: () => null,
-                maxRounds: this.maxRounds
-            });
-        }
-        catch (error) {
-            const message = `Request failed: ${toErrorMessage(error)}`;
-            state.history.push({ role: "assistant", content: message });
-            await this.persistSession(state);
-            return { text: message };
-        }
-        const finalText = latestAssistantText.trim().length > 0 ? latestAssistantText : "(no response)";
-        await this.persistSession(state);
-        return { text: finalText };
-    }
-    dispose() {
-        this.vtSession.dispose();
-        this.sessionStates.clear();
-    }
-    getOrCreateSessionState(context) {
-        const key = `${context.session.id}:${context.session.createdAt.toISOString()}`;
-        const existing = this.sessionStates.get(key);
-        if (existing) {
-            return existing;
-        }
-        const created = {
-            history: [],
-            sessionFilePath: null
-        };
-        this.sessionStates.set(key, created);
-        return created;
-    }
-    async persistSession(state) {
-        if (state.history.length === 0) {
-            return;
-        }
-        if (!state.sessionFilePath) {
-            const created = await this.deps.createSessionFile(state.history);
-            state.sessionFilePath = created.path;
-        }
-        await this.deps.writeSessionFile({
-            path: state.sessionFilePath,
-            username: this.username,
-            history: state.history
-        });
-    }
-}
-exports.GatewayHeadlessConductor = GatewayHeadlessConductor;
-async function createGatewayHeadlessMessageHandler(options, deps = {}) {
-    const runtime = new GatewayHeadlessConductor(options, deps);
-    await runtime.initialize();
-    return {
-        handleMessage: async (context) => await runtime.handleMessage(context),
-        dispose: () => {
-            runtime.dispose();
-        }
-    };
-}

package/dist/gateway/message-router.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeIncomingMessage = normalizeIncomingMessage;
-exports.validateIncomingMessage = validateIncomingMessage;
-const MAX_TEXT_LENGTH = 4000;
-function normalizeIncomingMessage(message) {
-    return {
-        ...message,
-        senderId: message.senderId.trim(),
-        channelId: message.channelId?.trim(),
-        text: message.text.trim().slice(0, MAX_TEXT_LENGTH),
-        timestamp: message.timestamp ?? new Date()
-    };
-}
-function validateIncomingMessage(message) {
-    if (message.senderId.trim().length === 0) {
-        return "sender_id_required";
-    }
-    if (message.text.trim().length === 0) {
-        return "message_text_required";
-    }
-    return null;
-}

package/dist/gateway/rate-limiter.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayRateLimiter = void 0;
-class GatewayRateLimiter {
-    maxMessages;
-    windowMs;
-    counters = new Map();
-    now;
-    constructor(options, now = () => new Date()) {
-        this.maxMessages = Math.max(1, Math.trunc(options.maxMessages));
-        this.windowMs = Math.max(1000, Math.trunc(options.windowMs));
-        this.now = now;
-    }
-    check(senderId) {
-        const now = this.now().valueOf();
-        const existing = this.counters.get(senderId);
-        const active = existing && now - existing.startedAt < this.windowMs ? existing : { count: 0, startedAt: now };
-        active.count += 1;
-        this.counters.set(senderId, active);
-        const resetAt = new Date(active.startedAt + this.windowMs);
-        if (active.count <= this.maxMessages) {
-            return {
-                allowed: true,
-                remaining: this.maxMessages - active.count,
-                retryAfterMs: 0,
-                resetAt
-            };
-        }
-        return {
-            allowed: false,
-            remaining: 0,
-            retryAfterMs: Math.max(1, active.startedAt + this.windowMs - now),
-            resetAt
-        };
-    }
-    pruneStaleCounters() {
-        const now = this.now().valueOf();
-        let removed = 0;
-        for (const [senderId, window] of this.counters) {
-            if (now - window.startedAt >= this.windowMs) {
-                this.counters.delete(senderId);
-                removed += 1;
-            }
-        }
-        return removed;
-    }
-}
-exports.GatewayRateLimiter = GatewayRateLimiter;