@bolt-foundry/gambit 0.6.0 → 0.6.2

package/script/packages/gambit-core/src/render.js

@@ -1,192 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-exports.renderDeck = renderDeck;
-const constants_1 = require("@bolt-foundry/gambit-core/internal/constants");
-const loader_1 = require("@bolt-foundry/gambit-core/internal/loader");
-const schema_js_1 = require("./schema.js");
-exports.logger = console;
-function normalizeContent(content) {
-    if (content === null)
-        return null;
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return String(content);
-    return content
-        .map((c) => (typeof c === "string" ? c : (c.text ?? "")))
-        .join("");
-}
-function normalizeMessages(input) {
-    return input.map((m) => ({
-        role: m.role,
-        content: normalizeContent(m.content),
-        name: m.name,
-        tool_call_id: m.tool_call_id,
-        tool_calls: m.tool_calls && m.tool_calls.length > 0
-            ? m.tool_calls
-            : undefined,
-    }));
-}
-function deckSystemPrompt(deck) {
-    const parts = [];
-    const prompt = deck.body ?? deck.prompt;
-    if (prompt)
-        parts.push(prompt.trim());
-    if (!deck.inlineEmbeds) {
-        for (const card of deck.cards) {
-            if (card.body)
-                parts.push(card.body.trim());
-        }
-    }
-    return parts.join("\n\n").trim();
-}
-function shouldPrependDeckSystem(messages, systemPrompt) {
-    if (!systemPrompt)
-        return false;
-    if (!messages.length)
-        return true;
-    const hasExact = messages.some((m) => m.role === "system" && m.content === systemPrompt);
-    return !hasExact;
-}
-function warnIfSystemMismatch(args) {
-    if (!args.systemPrompt)
-        return;
-    const existing = args.provided.find((m) => m.role === "system");
-    if (!existing)
-        return;
-    if (existing.content === args.systemPrompt)
-        return;
-    exports.logger.warn(`[gambit] renderDeck: request includes a system message that does not match the deck prompt (${args.deckPath})`);
-}
-function toolName(tool) {
-    return tool.function?.name ?? "";
-}
-function assertNoToolNameCollisions(args) {
-    if (!args.externalTools?.length)
-        return;
-    const gambit = new Set(args.gambitTools.map(toolName));
-    for (const t of args.externalTools) {
-        const name = toolName(t);
-        if (!name)
-            continue;
-        if (name.startsWith(constants_1.RESERVED_TOOL_PREFIX)) {
-            throw new Error(`External tool name ${name} is reserved (prefix ${constants_1.RESERVED_TOOL_PREFIX})`);
-        }
-        if (gambit.has(name)) {
-            throw new Error(`Tool name collision for ${name} between Gambit deck actions and external tools`);
-        }
-    }
-}
-async function buildDeckActionTools(deckPath) {
-    const deck = await (0, loader_1.loadDeck)(deckPath);
-    const tools = [];
-    const actionPathsByName = {};
-    for (const action of deck.actionDecks) {
-        const child = await (0, loader_1.loadDeck)(action.path, deck.path);
-        if (!child.inputSchema || !child.outputSchema) {
-            throw new Error(`Deck ${child.path} must declare inputSchema and outputSchema (non-root)`);
-        }
-        (0, schema_js_1.assertZodSchema)(child.inputSchema, "inputSchema");
-        (0, schema_js_1.assertZodSchema)(child.outputSchema, "outputSchema");
-        const params = (0, schema_js_1.toJsonSchema)(child.inputSchema);
-        tools.push({
-            type: "function",
-            function: {
-                name: action.name,
-                description: action.description,
-                parameters: params,
-            },
-        });
-        actionPathsByName[action.name] = action.path;
-    }
-    return { tools, actionPathsByName };
-}
-function mergeModelParams(req, deckParams) {
-    const out = { ...req };
-    if (!deckParams)
-        return out;
-    if (out.model === undefined && deckParams.model)
-        out.model = deckParams.model;
-    if (out.temperature === undefined && deckParams.temperature !== undefined) {
-        out.temperature = deckParams.temperature;
-    }
-    if (out.top_p === undefined && deckParams.top_p !== undefined) {
-        out.top_p = deckParams.top_p;
-    }
-    if (out.frequency_penalty === undefined &&
-        deckParams.frequency_penalty !== undefined) {
-        out.frequency_penalty = deckParams.frequency_penalty;
-    }
-    if (out.presence_penalty === undefined &&
-        deckParams.presence_penalty !== undefined) {
-        out.presence_penalty = deckParams.presence_penalty;
-    }
-    if (out.max_tokens === undefined && deckParams.max_tokens !== undefined) {
-        out.max_tokens = deckParams.max_tokens;
-    }
-    return out;
-}
-async function renderDeck(opts) {
-    const includeDeckSystem = opts.includeDeckSystem ?? true;
-    const includeDeckTools = opts.includeDeckTools ?? true;
-    const warnOnSystemMismatch = opts.warnOnSystemMismatch ?? true;
-    const deck = await (0, loader_1.loadDeck)(opts.deckPath);
-    const systemPrompt = deckSystemPrompt(deck);
-    const mergedReq = mergeModelParams(opts.request, deck.modelParams);
-    const providedMessages = normalizeMessages(mergedReq.messages);
-    const messages = [];
-    if (includeDeckSystem) {
-        if (warnOnSystemMismatch) {
-            warnIfSystemMismatch({
-                provided: providedMessages,
-                systemPrompt,
-                deckPath: deck.path,
-            });
-        }
-        if (shouldPrependDeckSystem(providedMessages, systemPrompt)) {
-            messages.push({ role: "system", content: systemPrompt });
-        }
-    }
-    messages.push(...providedMessages);
-    let tools = undefined;
-    let actionPathsByName = {};
-    if (includeDeckTools) {
-        const built = await buildDeckActionTools(deck.path);
-        actionPathsByName = built.actionPathsByName;
-        assertNoToolNameCollisions({
-            gambitTools: built.tools,
-            externalTools: mergedReq.tools,
-        });
-        tools = mergedReq.tools?.length
-            ? [...built.tools, ...mergedReq.tools]
-            : built.tools;
-    }
-    else if (mergedReq.tools?.length) {
-        for (const t of mergedReq.tools) {
-            const name = toolName(t);
-            if (name.startsWith(constants_1.RESERVED_TOOL_PREFIX)) {
-                throw new Error(`External tool name ${name} is reserved (prefix ${constants_1.RESERVED_TOOL_PREFIX})`);
-            }
-        }
-        tools = mergedReq.tools;
-    }
-    const model = String(mergedReq.model ?? "").trim();
-    if (!model) {
-        throw new Error(`renderDeck requires request.model (or deck.modelParams.model): ${deck.path}`);
-    }
-    const { messages: _m, tools: _t, ...rest } = mergedReq;
-    return {
-        request: {
-            ...rest,
-            model,
-            messages,
-            tools: tools && tools.length ? tools : undefined,
-        },
-        gambit: {
-            deckPath: deck.path,
-            systemPrompt,
-            actionPathsByName,
-        },
-    };
-}

package/script/packages/gambit-core/src/schema.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-import type { JSONValue } from "@bolt-foundry/gambit-core/internal/types";
-import type { ZodTypeAny } from "zod";
-export declare function validateWithSchema<T>(schema: z.ZodType<T>, value: unknown): T;
-export declare function toJsonSchema(schema: z.ZodTypeAny): Record<string, JSONValue>;
-export declare function assertZodSchema(value: unknown, label: string): asserts value is z.ZodTypeAny;
-export declare function mergeZodObjects(base: ZodTypeAny | undefined, fragment: ZodTypeAny | undefined): ZodTypeAny | undefined;
-//# sourceMappingURL=schema.d.ts.map

package/script/packages/gambit-core/src/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/packages/gambit-core/src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0CAA0C,CAAC;AAC1E,OAAO,KAAK,EAA0B,UAAU,EAAE,MAAM,KAAK,CAAC;AAE9D,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,OAAO,GACb,CAAC,CAUH;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAO5E;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,UAAU,CAQ/B;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,QAAQ,EAAE,UAAU,GAAG,SAAS,GAC/B,UAAU,GAAG,SAAS,CAOxB"}

package/script/packages/gambit-core/src/schema.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateWithSchema = validateWithSchema;
-exports.toJsonSchema = toJsonSchema;
-exports.assertZodSchema = assertZodSchema;
-exports.mergeZodObjects = mergeZodObjects;
-const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-function validateWithSchema(schema, value) {
-    const result = schema.safeParse(value);
-    if (!result.success) {
-        const issue = result.error.issues?.[0];
-        const message = issue
-            ? `${issue.path.join(".") || "(root)"}: ${issue.message}`
-            : result.error.message;
-        throw new Error(`Schema validation failed: ${message}`);
-    }
-    return result.data;
-}
-function toJsonSchema(schema) {
-    const converted = (0, zod_to_json_schema_1.zodToJsonSchema)(schema, { $refStrategy: "none" });
-    if (converted && typeof converted === "object") {
-        return converted;
-    }
-    // Fallback to permissive object if conversion fails
-    return { type: "object" };
-}
-function assertZodSchema(value, label) {
-    if (!value || typeof value !== "object") {
-        throw new Error(`${label} must be a Zod schema`);
-    }
-    // Duck-typing: check for safeParse
-    if (typeof value.safeParse !== "function") {
-        throw new Error(`${label} must be a Zod schema (missing safeParse)`);
-    }
-}
-function mergeZodObjects(base, fragment) {
-    if (!fragment)
-        return base;
-    if (!base)
-        return fragment;
-    const baseObj = asZodObject(base, "base schema");
-    const fragObj = asZodObject(fragment, "fragment schema");
-    const mergedShape = { ...fragObj.shape, ...baseObj.shape };
-    return zod_1.z.object(mergedShape);
-}
-function asZodObject(schema, label) {
-    if (schema instanceof zod_1.z.ZodObject)
-        return schema;
-    throw new Error(`${label} must be a Zod object schema to merge fragments`);
-}