@yak-io/javascript 0.1.0

package/dist/schema-parser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Client-side Schema Parser
+ *
+ * Parses GraphQL schemas and OpenAPI specs into ToolDefinitions.
+ * This is a simplified version suitable for browser environments.
+ */
+import type { ToolDefinition, SchemaSource, ToolManifest } from "./types/tools.js";
+/**
+ * Parses schema sources into tool definitions
+ */
+export declare function parseSchemaSources(sources: SchemaSource[]): ToolDefinition[];
+/**
+ * Expands a tool manifest by parsing any schema sources into tool definitions.
+ * Use this to pre-process the manifest before passing to YakProvider.
+ */
+export declare function expandToolManifest(manifest: ToolManifest): ToolManifest;
+/**
+ * Builds an executable request from a tool definition and provided arguments.
+ */
+export declare function buildExecutableRequest(tool: ToolDefinition, args: Record<string, unknown>): import("./types/tools.js").ExecutableRequest | undefined;
+//# sourceMappingURL=schema-parser.d.ts.map

package/dist/schema-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-parser.d.ts","sourceRoot":"","sources":["../src/schema-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,cAAc,EAGd,YAAY,EAEZ,YAAY,EACb,MAAM,kBAAkB,CAAC;AAyV1B;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,cAAc,EAAE,CAgB5E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,CAavE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,kBAAkB,EAAE,iBAAiB,GAAG,SAAS,CAuD1D"}

package/dist/schema-parser.js

@@ -0,0 +1,341 @@
+/**
+ * Client-side Schema Parser
+ *
+ * Parses GraphQL schemas and OpenAPI specs into ToolDefinitions.
+ * This is a simplified version suitable for browser environments.
+ */
+function graphqlTypeToJsonSchema(type) {
+    const baseType = type.replace(/!/g, "").replace(/\[|\]/g, "").trim();
+    const isArray = type.includes("[");
+    let schema;
+    switch (baseType.toLowerCase()) {
+        case "string":
+        case "id":
+            schema = { type: "string" };
+            break;
+        case "int":
+            schema = { type: "integer" };
+            break;
+        case "float":
+            schema = { type: "number" };
+            break;
+        case "boolean":
+            schema = { type: "boolean" };
+            break;
+        default:
+            schema = { type: "object" };
+    }
+    if (isArray) {
+        schema = { type: "array", items: schema };
+    }
+    return schema;
+}
+function parseGraphQLSDL(sdl) {
+    const result = { queries: [], mutations: [] };
+    const fieldPattern = /(\w+)\s*(?:\(([^)]*)\))?\s*:\s*([^\n}]+)/g;
+    const argPattern = /(\w+)\s*:\s*([^,)]+)/g;
+    const queryMatch = sdl.match(/type\s+Query\s*\{([^}]+)\}/s);
+    if (queryMatch?.[1]) {
+        const queryBody = queryMatch[1];
+        let fieldMatch = null;
+        fieldPattern.lastIndex = 0;
+        while ((fieldMatch = fieldPattern.exec(queryBody)) !== null) {
+            const name = fieldMatch[1];
+            const argsStr = fieldMatch[2];
+            const returnType = fieldMatch[3];
+            if (!name || !returnType)
+                continue;
+            const args = [];
+            if (argsStr) {
+                let argMatch = null;
+                argPattern.lastIndex = 0;
+                while ((argMatch = argPattern.exec(argsStr)) !== null) {
+                    const argName = argMatch[1];
+                    const argType = argMatch[2];
+                    if (!argName || !argType)
+                        continue;
+                    args.push({
+                        name: argName,
+                        type: argType.trim(),
+                        required: argType.includes("!"),
+                    });
+                }
+            }
+            result.queries.push({ name, type: returnType.trim(), args });
+        }
+    }
+    const mutationMatch = sdl.match(/type\s+Mutation\s*\{([^}]+)\}/s);
+    if (mutationMatch?.[1]) {
+        const mutationBody = mutationMatch[1];
+        let fieldMatch = null;
+        fieldPattern.lastIndex = 0;
+        while ((fieldMatch = fieldPattern.exec(mutationBody)) !== null) {
+            const name = fieldMatch[1];
+            const argsStr = fieldMatch[2];
+            const returnType = fieldMatch[3];
+            if (!name || !returnType)
+                continue;
+            const args = [];
+            if (argsStr) {
+                let argMatch = null;
+                argPattern.lastIndex = 0;
+                while ((argMatch = argPattern.exec(argsStr)) !== null) {
+                    const argName = argMatch[1];
+                    const argType = argMatch[2];
+                    if (!argName || !argType)
+                        continue;
+                    args.push({
+                        name: argName,
+                        type: argType.trim(),
+                        required: argType.includes("!"),
+                    });
+                }
+            }
+            result.mutations.push({ name, type: returnType.trim(), args });
+        }
+    }
+    return result;
+}
+function generateGraphQLOperation(field, operationType) {
+    const args = field.args.map((arg) => `$${arg.name}: ${arg.type}`).join(", ");
+    const variables = field.args.map((arg) => `${arg.name}: $${arg.name}`).join(", ");
+    const argsDecl = args ? `(${args})` : "";
+    const varsUsage = variables ? `(${variables})` : "";
+    return `${operationType}${argsDecl} { ${field.name}${varsUsage} }`;
+}
+function parseGraphQLSchema(source) {
+    const tools = [];
+    const parsed = parseGraphQLSDL(source.schema);
+    const includeSet = source.include ? new Set(source.include) : null;
+    const excludeSet = source.exclude ? new Set(source.exclude) : null;
+    const opTypes = source.operationTypes ?? ["query", "mutation"];
+    const processField = (field, operationType) => {
+        if (includeSet && !includeSet.has(field.name))
+            return;
+        if (excludeSet && excludeSet.has(field.name))
+            return;
+        const properties = {};
+        const required = [];
+        for (const arg of field.args) {
+            properties[arg.name] = {
+                ...graphqlTypeToJsonSchema(arg.type),
+                description: arg.description,
+            };
+            if (arg.required) {
+                required.push(arg.name);
+            }
+        }
+        const inputSchema = {
+            type: "object",
+            properties,
+            required: required.length > 0 ? required : undefined,
+            additionalProperties: false,
+        };
+        const operation = generateGraphQLOperation(field, operationType);
+        tools.push({
+            name: `graphql.${field.name}`,
+            displayName: field.name,
+            description: field.description ?? `${operationType === "query" ? "Query" : "Mutate"}: ${field.name}`,
+            inputSchema,
+            requestTemplate: {
+                type: "graphql",
+                endpoint: source.endpoint,
+                operation,
+            },
+            source: `graphql:${field.name}`,
+        });
+    };
+    if (opTypes.includes("query")) {
+        for (const query of parsed.queries) {
+            processField(query, "query");
+        }
+    }
+    if (opTypes.includes("mutation")) {
+        for (const mutation of parsed.mutations) {
+            processField(mutation, "mutation");
+        }
+    }
+    return tools;
+}
+function parseOpenAPISpec(spec) {
+    if (typeof spec === "string") {
+        try {
+            return JSON.parse(spec);
+        }
+        catch {
+            console.warn("[yak] OpenAPI spec must be valid JSON");
+            return { paths: {} };
+        }
+    }
+    return spec;
+}
+function parseOpenAPISchema(source) {
+    const tools = [];
+    const spec = parseOpenAPISpec(source.spec);
+    const baseUrl = source.baseUrl ?? spec.servers?.[0]?.url ?? "";
+    const includeSet = source.include ? new Set(source.include) : null;
+    const excludeSet = source.exclude ? new Set(source.exclude) : null;
+    const methods = source.methods ?? ["get", "post", "put", "patch", "delete"];
+    if (!spec.paths)
+        return tools;
+    for (const [path, pathItem] of Object.entries(spec.paths)) {
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (!operation)
+                continue;
+            const operationId = operation.operationId ?? `${method}_${path.replace(/[^a-zA-Z0-9]/g, "_")}`;
+            if (includeSet && !includeSet.has(operationId))
+                continue;
+            if (excludeSet && excludeSet.has(operationId))
+                continue;
+            const properties = {};
+            const required = [];
+            const pathParams = {};
+            const queryParams = {};
+            if (operation.parameters) {
+                for (const param of operation.parameters) {
+                    properties[param.name] = {
+                        ...(param.schema ?? { type: "string" }),
+                        description: param.description,
+                    };
+                    if (param.required) {
+                        required.push(param.name);
+                    }
+                    if (param.in === "path") {
+                        pathParams[param.name] = param.name;
+                    }
+                    else if (param.in === "query") {
+                        queryParams[param.name] = param.name;
+                    }
+                }
+            }
+            let bodyParams;
+            const bodySchema = operation.requestBody?.content?.["application/json"]?.schema;
+            if (bodySchema?.properties) {
+                bodyParams = {};
+                for (const [propName, propSchema] of Object.entries(bodySchema.properties)) {
+                    properties[propName] = propSchema;
+                    bodyParams[propName] = propName;
+                }
+                if (bodySchema.required) {
+                    required.push(...bodySchema.required);
+                }
+            }
+            const inputSchema = {
+                type: "object",
+                properties,
+                required: required.length > 0 ? required : undefined,
+                additionalProperties: false,
+            };
+            tools.push({
+                name: `api.${operationId}`,
+                displayName: operation.summary ?? operationId,
+                description: operation.description ?? operation.summary ?? `${method.toUpperCase()} ${path}`,
+                inputSchema,
+                requestTemplate: {
+                    type: "rest",
+                    url: `${baseUrl}${path}`,
+                    method: method.toUpperCase(),
+                    ...(Object.keys(pathParams).length > 0 && { pathParams }),
+                    ...(Object.keys(queryParams).length > 0 && { queryParams }),
+                    ...(bodyParams && { bodyParams }),
+                },
+                source: `openapi:${operationId}`,
+            });
+        }
+    }
+    return tools;
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Parses schema sources into tool definitions
+ */
+export function parseSchemaSources(sources) {
+    const tools = [];
+    for (const source of sources) {
+        try {
+            if (source.type === "graphql") {
+                tools.push(...parseGraphQLSchema(source));
+            }
+            else if (source.type === "openapi") {
+                tools.push(...parseOpenAPISchema(source));
+            }
+        }
+        catch (error) {
+            console.error(`[yak] Failed to parse ${source.type} schema:`, error);
+        }
+    }
+    return tools;
+}
+/**
+ * Expands a tool manifest by parsing any schema sources into tool definitions.
+ * Use this to pre-process the manifest before passing to YakProvider.
+ */
+export function expandToolManifest(manifest) {
+    if (!manifest.schemaSources?.length) {
+        return manifest;
+    }
+    const expandedTools = parseSchemaSources(manifest.schemaSources);
+    return {
+        ...manifest,
+        tools: [...manifest.tools, ...expandedTools],
+        // Clear schemaSources since they've been expanded
+        schemaSources: undefined,
+    };
+}
+/**
+ * Builds an executable request from a tool definition and provided arguments.
+ */
+export function buildExecutableRequest(tool, args) {
+    const template = tool.requestTemplate;
+    if (!template)
+        return undefined;
+    if (template.type === "graphql") {
+        return {
+            type: "graphql",
+            endpoint: template.endpoint,
+            query: template.operation,
+            variables: args,
+        };
+    }
+    // REST request
+    let url = template.url;
+    if (template.pathParams) {
+        for (const [param, argName] of Object.entries(template.pathParams)) {
+            const value = args[argName];
+            if (value !== undefined) {
+                url = url.replace(`{${param}}`, String(value));
+            }
+        }
+    }
+    if (template.queryParams) {
+        const queryEntries = [];
+        for (const [, argName] of Object.entries(template.queryParams)) {
+            const value = args[argName];
+            if (value !== undefined) {
+                queryEntries.push(`${encodeURIComponent(argName)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        if (queryEntries.length > 0) {
+            url += (url.includes("?") ? "&" : "?") + queryEntries.join("&");
+        }
+    }
+    let body;
+    if (template.bodyParams) {
+        body = {};
+        for (const [, argName] of Object.entries(template.bodyParams)) {
+            if (args[argName] !== undefined) {
+                body[argName] = args[argName];
+            }
+        }
+    }
+    return {
+        type: "rest",
+        url,
+        method: template.method,
+        headers: { "Content-Type": "application/json" },
+        body: body && Object.keys(body).length > 0 ? body : undefined,
+    };
+}

package/dist/server/createYakHandler.d.ts

@@ -0,0 +1,19 @@
+import type { RouteSourceInput, ToolSourceInput } from "./sources.js";
+export type YakHandlerConfig = {
+    routes: RouteSourceInput;
+    tools?: ToolSourceInput;
+};
+export declare function createYakHandler(config: YakHandlerConfig): {
+    GET: (_req: Request) => Promise<Response>;
+    POST: (req: Request) => Promise<Response>;
+};
+export type YakConfigHandlerConfig = {
+    routes: RouteSourceInput;
+    tools?: ToolSourceInput;
+};
+export declare function createYakConfigHandler(config: YakConfigHandlerConfig): (_req: Request) => Promise<Response>;
+export type YakToolsHandlerConfig = {
+    tools: ToolSourceInput;
+};
+export declare function createYakToolsHandler(config: YakToolsHandlerConfig): (req: Request) => Promise<Response>;
+//# sourceMappingURL=createYakHandler.d.ts.map

package/dist/server/createYakHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createYakHandler.d.ts","sourceRoot":"","sources":["../../src/server/createYakHandler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAe,eAAe,EAAc,MAAM,cAAc,CAAC;AAE/F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB;gBAIT,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC;gBAezB,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC;EA6C5E;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,sBAAsB,IAIhC,MAAM,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC,CAcrE;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,IAO/B,KAAK,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC,CAsCnE"}

package/dist/server/createYakHandler.js

@@ -0,0 +1,185 @@
+import { normalizeRouteSources, normalizeToolSources } from "./sources.js";
+export function createYakHandler(config) {
+    const routeSources = normalizeRouteSources(config.routes);
+    const toolSources = normalizeToolSources(config.tools);
+    const GET = async function handleConfig(_req) {
+        const chatConfig = {
+            routes: await buildRouteManifest(routeSources),
+        };
+        if (toolSources.length > 0) {
+            const { manifest } = await buildToolRegistry(toolSources);
+            chatConfig.tools = manifest;
+        }
+        return jsonResponse(chatConfig, 200, {
+            "Cache-Control": "no-store",
+        });
+    };
+    const POST = async function handleToolCall(req) {
+        if (toolSources.length === 0) {
+            return errorResponse("Tool execution is not configured", 501);
+        }
+        let payload;
+        try {
+            payload = await req.json();
+        }
+        catch {
+            return errorResponse("Invalid JSON payload", 400);
+        }
+        if (!isHostToolCallPayload(payload)) {
+            return errorResponse("Invalid tool call payload", 400);
+        }
+        try {
+            const { lookup } = await buildToolRegistry(toolSources);
+            const owner = lookup.get(payload.name);
+            if (!owner) {
+                return createToolErrorResponse(`Tool '${payload.name}' is not registered`);
+            }
+            if (!owner.executeTool) {
+                return createToolErrorResponse(`Tool '${payload.name}' does not expose an executor`);
+            }
+            const result = await owner.executeTool(payload.name, payload.args, req);
+            const successResult = {
+                ok: true,
+                result,
+            };
+            return jsonResponse(successResult);
+        }
+        catch (error) {
+            return createToolErrorResponse(extractErrorMessage(error));
+        }
+    };
+    return { GET, POST };
+}
+export function createYakConfigHandler(config) {
+    const routeSources = normalizeRouteSources(config.routes);
+    const toolSources = normalizeToolSources(config.tools);
+    return async function handleConfig(_req) {
+        const chatConfig = {
+            routes: await buildRouteManifest(routeSources),
+        };
+        if (toolSources.length > 0) {
+            const { manifest } = await buildToolRegistry(toolSources);
+            chatConfig.tools = manifest;
+        }
+        return jsonResponse(chatConfig, 200, {
+            "Cache-Control": "no-store",
+        });
+    };
+}
+export function createYakToolsHandler(config) {
+    const toolSources = normalizeToolSources(config.tools);
+    if (toolSources.length === 0) {
+        throw new Error("createYakToolsHandler requires at least one tool source");
+    }
+    return async function handleTools(req) {
+        let payload;
+        try {
+            payload = await req.json();
+        }
+        catch {
+            return errorResponse("Invalid JSON payload", 400);
+        }
+        if (!isHostToolCallPayload(payload)) {
+            return errorResponse("Invalid tool call payload", 400);
+        }
+        try {
+            const { lookup } = await buildToolRegistry(toolSources);
+            const owner = lookup.get(payload.name);
+            if (!owner) {
+                return createToolErrorResponse(`Tool '${payload.name}' is not registered`);
+            }
+            if (!owner.executeTool) {
+                return createToolErrorResponse(`Tool '${payload.name}' does not expose an executor`);
+            }
+            const result = await owner.executeTool(payload.name, payload.args, req);
+            const successResult = {
+                ok: true,
+                result,
+            };
+            return jsonResponse(successResult);
+        }
+        catch (error) {
+            return createToolErrorResponse(extractErrorMessage(error));
+        }
+    };
+}
+async function buildRouteManifest(routeSources) {
+    const entries = await Promise.all(routeSources.map(async (source) => ({
+        id: source.id ?? "routes",
+        routes: await source.getRoutes(),
+    })));
+    const merged = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        for (const route of entry.routes) {
+            const key = route.path;
+            if (!seen.has(key)) {
+                seen.add(key);
+                merged.push(route);
+            }
+        }
+    }
+    merged.sort((a, b) => a.path.localeCompare(b.path));
+    return {
+        routes: merged,
+        generated_at: new Date().toISOString(),
+        sources: entries.map((entry) => ({ id: entry.id, count: entry.routes.length })),
+    };
+}
+async function buildToolRegistry(toolSources) {
+    const entries = await Promise.all(toolSources.map(async (source) => ({
+        id: source.id ?? "tools",
+        source,
+        tools: await source.getTools(),
+    })));
+    const manifestTools = [];
+    const lookup = new Map();
+    for (const entry of entries) {
+        for (const tool of entry.tools) {
+            manifestTools.push(tool);
+            lookup.set(tool.name, entry.source);
+        }
+    }
+    return {
+        manifest: {
+            tools: manifestTools,
+            generated_at: new Date().toISOString(),
+            sources: entries.map((entry) => ({ id: entry.id, count: entry.tools.length })),
+        },
+        lookup,
+    };
+}
+function isHostToolCallPayload(payload) {
+    return (typeof payload === "object" &&
+        payload !== null &&
+        typeof payload.name === "string" &&
+        "args" in payload);
+}
+function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "An unknown error occurred";
+}
+function jsonResponse(body, status = 200, headers = {}) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: {
+            "Content-Type": "application/json",
+            ...headers,
+        },
+    });
+}
+function errorResponse(message, status) {
+    return jsonResponse({ error: message }, status);
+}
+function createToolErrorResponse(error) {
+    const errorResult = {
+        ok: false,
+        error,
+    };
+    return jsonResponse(errorResult);
+}

package/dist/server/index.d.ts

@@ -0,0 +1,8 @@
+export { createYakHandler, createYakConfigHandler, createYakToolsHandler, } from "./createYakHandler.js";
+export type { YakHandlerConfig, YakConfigHandlerConfig, YakToolsHandlerConfig, } from "./createYakHandler.js";
+export { normalizeRouteSources, normalizeToolSources, } from "./sources.js";
+export type { RouteSource, RouteSourceInput, ToolSource, ToolSourceInput } from "./sources.js";
+export type { ToolExecutor, ToolDefinition, ToolManifest, ToolCallPayload, ToolCallResult, } from "../types/tools.js";
+export type { RouteInfo, RouteManifest } from "../types/routes.js";
+export type { ChatConfig } from "../types/config.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/F,YAAY,EACV,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,eAAe,EACf,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,2 @@
+export { createYakHandler, createYakConfigHandler, createYakToolsHandler, } from "./createYakHandler.js";
+export { normalizeRouteSources, normalizeToolSources, } from "./sources.js";

package/dist/server/sources.d.ts

@@ -0,0 +1,24 @@
+import type { RouteInfo } from "../types/routes.js";
+import type { ToolDefinition, ToolManifest, ToolExecutor } from "../types/tools.js";
+export type RouteSource = {
+    id?: string;
+    getRoutes: () => Promise<RouteInfo[]>;
+};
+type RouteSourceFn = () => Promise<RouteInfo[]>;
+type RouteSourceInputItem = RouteSource | RouteSourceFn | RouteInfo[];
+export type RouteSourceInput = RouteSourceInputItem | RouteSourceInputItem[];
+export type ToolSource = {
+    id?: string;
+    getTools: () => Promise<ToolDefinition[]>;
+    executeTool?: ToolExecutor;
+};
+type ToolSourceFn = () => Promise<ToolDefinition[] | ToolManifest>;
+type ToolSourceInputItem = ToolSource | ToolSourceFn | ToolDefinition[] | ToolManifest | {
+    getTools: ToolSourceFn;
+    executeTool?: ToolExecutor;
+};
+export type ToolSourceInput = ToolSourceInputItem | ToolSourceInputItem[];
+export declare function normalizeRouteSources(input: RouteSourceInput): RouteSource[];
+export declare function normalizeToolSources(input?: ToolSourceInput): ToolSource[];
+export {};
+//# sourceMappingURL=sources.d.ts.map

package/dist/server/sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources.d.ts","sourceRoot":"","sources":["../../src/server/sources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEpF,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;CACvC,CAAC;AAEF,KAAK,aAAa,GAAG,MAAM,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;AAEhD,KAAK,oBAAoB,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,EAAE,CAAC;AAEtE,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,oBAAoB,EAAE,CAAC;AAE7E,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC1C,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,KAAK,YAAY,GAAG,MAAM,OAAO,CAAC,cAAc,EAAE,GAAG,YAAY,CAAC,CAAC;AAEnE,KAAK,mBAAmB,GACpB,UAAU,GACV,YAAY,GACZ,cAAc,EAAE,GAChB,YAAY,GACZ;IACE,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEN,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,mBAAmB,EAAE,CAAC;AAqC1E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,WAAW,EAAE,CAY5E;AA4ED,wBAAgB,oBAAoB,CAAC,KAAK,CAAC,EAAE,eAAe,GAAG,UAAU,EAAE,CAe1E"}