@accordproject/template-engine 4.0.0 → 5.0.0

package/lib/llm/ModelManagerSchema.js

@@ -0,0 +1,67 @@
+"use strict";
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.treeShakeModel = treeShakeModel;
+// ModelManager tree-shaking.
+//
+// Instead of loading a pre-generated schema.json and guessing which definition
+// is the "request" / "response" / "state" / "event" by matching on the type
+// name (which breaks for templates that call their response `PayOut`, `Payout`,
+// etc.), we:
+//
+//   1. ask the Template for the *exact* fully-qualified type names it declares
+//      (these are reliable because they are computed from the runtime base
+//      classes the types extend, not from their names);
+//   2. build a dependency graph of the whole ModelManager;
+//   3. tree-shake that graph down to only the types reachable from the roots we
+//      care about; and
+//   4. generate a minimal JSON Schema from that subgraph.
+//
+// See concerto-codegen `lib/common/graph.js` (ConcertoGraphVisitor +
+// DirectedGraph.findConnectedGraph) and `test/common/graph.js` for the upstream
+// pattern this mirrors.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const codegen = require('@accordproject/concerto-codegen');
+const { ConcertoGraphVisitor, DirectedGraph } = codegen.Common;
+const { JSONSchemaVisitor } = codegen.CodeGen;
+/**
+ * Tree-shake a template's ModelManager down to only the declarations reachable
+ * from `roots`, returning both the JSON Schema definitions and the reduced
+ * model files.
+ *
+ * @param template  a cicero-core Template
+ * @param roots     fully-qualified type names to keep (and their dependencies)
+ */
+function treeShakeModel(template, roots) {
+    const modelManager = template.getModelManager();
+    // 1. Build the full dependency graph: every type is a vertex, every field /
+    //    relationship / supertype / decorator reference is an edge.
+    const graph = new DirectedGraph();
+    modelManager.accept(new ConcertoGraphVisitor(), {
+        graph,
+        // Add reverse edges supertype -> subtype so that keeping a base type also
+        // keeps its concrete subtypes (needed for abstract request/response bases).
+        includeDerivedTypes: true,
+    });
+    // 2. BFS from the roots to find the maximal connected subgraph.
+    const connected = graph.findConnectedGraph(roots);
+    // 3. Filter the ModelManager to just the reachable declarations.
+    const filtered = modelManager.filter((decl) => connected.hasVertex(decl.getFullyQualifiedName()));
+    // 4. Generate JSON Schema definitions 
+    const schema = filtered.accept(new JSONSchemaVisitor(), {});
+    return { definitions: schema.definitions ?? {} };
+}
+//# sourceMappingURL=ModelManagerSchema.js.map

package/lib/llm/ModelManagerSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelManagerSchema.js","sourceRoot":"","sources":["../../src/llm/ModelManagerSchema.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;AACH,uDAAuD;;AAyCvD,wCAyBC;AAhED,6BAA6B;AAC7B,EAAE;AACF,+EAA+E;AAC/E,4EAA4E;AAC5E,gFAAgF;AAChF,aAAa;AACb,EAAE;AACF,+EAA+E;AAC/E,2EAA2E;AAC3E,wDAAwD;AACxD,2DAA2D;AAC3D,gFAAgF;AAChF,uBAAuB;AACvB,0DAA0D;AAC1D,EAAE;AACF,qEAAqE;AACrE,gFAAgF;AAChF,wBAAwB;AAExB,iEAAiE;AACjE,MAAM,OAAO,GAAG,OAAO,CAAC,iCAAiC,CAAC,CAAC;AAC3D,MAAM,EAAE,oBAAoB,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;AAC/D,MAAM,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;AAS9C;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,QAAa,EAAE,KAAe;IAC3D,MAAM,YAAY,GAAG,QAAQ,CAAC,eAAe,EAAE,CAAC;IAEhD,4EAA4E;IAC5E,gEAAgE;IAChE,MAAM,KAAK,GAAG,IAAI,aAAa,EAAE,CAAC;IAClC,YAAY,CAAC,MAAM,CAAC,IAAI,oBAAoB,EAAE,EAAE;QAC9C,KAAK;QACL,0EAA0E;QAC1E,4EAA4E;QAC5E,mBAAmB,EAAE,IAAI;KAC1B,CAAC,CAAC;IAEH,gEAAgE;IAChE,MAAM,SAAS,GAAG,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAElD,iEAAiE;IACjE,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,IAAS,EAAE,EAAE,CACjD,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC,CAClD,CAAC;IAEF,uCAAuC;IACvC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,iBAAiB,EAAE,EAAE,EAAE,CAAC,CAAC;IAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;AACnD,CAAC"}

package/lib/llm/Reasoners.d.ts

@@ -0,0 +1,190 @@
+import { LLMProviderConfig, GroqProviderConfig, OpenAIProviderConfig, AnthropicProviderConfig, GoogleProviderConfig, MistralProviderConfig, OpenRouterProviderConfig, OllamaProviderConfig, OpenAICompatibleProviderConfig, BaseProviderConfig, OpenAIEffort } from './LLMConfig';
+/**
+ * A single chat turn sent to a provider.
+ */
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Raw content returned by a provider.
+ */
+export interface ReasonerResult {
+    content: string;
+}
+export type JsonSchema = Record<string, unknown>;
+/**
+ * Base interface for provider-specific reasoners.
+ */
+export declare abstract class BaseReasoner {
+    /**
+     * Completes a chat request.
+     * @param messages - conversation turns
+     * @param schema - optional JSON Schema for structured output
+     */
+    abstract complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * Groq-backed reasoner.
+ */
+export declare class GroqReasoner extends BaseReasoner {
+    private clientPromise?;
+    private readonly config;
+    constructor(config: GroqProviderConfig);
+    /**
+     * Loads the Groq client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+interface OpenAIChatMessageParam {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface OpenAIResponseFormat {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        strict: boolean;
+        schema: JsonSchema;
+    };
+}
+interface OpenAIChatCompletionCreateParams {
+    model: string;
+    messages: OpenAIChatMessageParam[];
+    stream: false;
+    response_format?: OpenAIResponseFormat;
+    /** Reasoning depth; reasoning models only. */
+    reasoning_effort?: OpenAIEffort;
+    /** OpenAI-native token limit field. */
+    max_completion_tokens?: number;
+    /** Legacy token limit field used by OpenAI-compatible APIs. */
+    max_tokens?: number;
+}
+interface OpenAIChatCompletionResponse {
+    choices?: Array<{
+        message?: {
+            content?: string | null;
+        };
+    }>;
+}
+interface OpenAIClient {
+    chat: {
+        completions: {
+            create: (args: OpenAIChatCompletionCreateParams) => Promise<OpenAIChatCompletionResponse>;
+        };
+    };
+}
+/**
+ * OpenAI-backed reasoner.
+ */
+export declare class OpenAIReasoner extends BaseReasoner {
+    private clientPromise?;
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    private readonly effort?;
+    constructor(config: OpenAIProviderConfig);
+    /**
+     * Loads the OpenAI client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * Anthropic-backed reasoner.
+ */
+export declare class AnthropicReasoner extends BaseReasoner {
+    private clientPromise?;
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    private readonly effort?;
+    private readonly thinking;
+    constructor(config: AnthropicProviderConfig);
+    /**
+     * Loads the Anthropic client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * Base reasoner for providers that expose an OpenAI-compatible chat API.
+ */
+export declare class OpenAICompatibleReasoner extends BaseReasoner {
+    protected clientPromise?: Promise<OpenAIClient>;
+    protected readonly apiKey: string;
+    protected readonly model: string;
+    protected readonly maxTokens: number;
+    protected readonly baseUrl: string;
+    constructor(config: BaseProviderConfig, baseUrl: string, defaultApiKey?: string);
+    /**
+     * Loads the OpenAI-compatible client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * OpenRouter-backed reasoner.
+ */
+export declare class OpenRouterReasoner extends BaseReasoner {
+    private clientPromise?;
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    constructor(config: OpenRouterProviderConfig);
+    /**
+     * Loads the OpenRouter client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * Ollama-backed reasoner.
+ */
+export declare class OllamaReasoner extends OpenAICompatibleReasoner {
+    constructor(config: OllamaProviderConfig);
+}
+/**
+ * Reasoner for arbitrary OpenAI-compatible endpoints.
+ */
+export declare class OpenAICompatibleCustomReasoner extends OpenAICompatibleReasoner {
+    constructor(config: OpenAICompatibleProviderConfig);
+}
+/**
+ * Google-backed reasoner.
+ */
+export declare class GoogleReasoner extends BaseReasoner {
+    private clientPromise?;
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    constructor(config: GoogleProviderConfig);
+    /**
+     * Loads the Google client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * Mistral-backed reasoner.
+ */
+export declare class MistralReasoner extends BaseReasoner {
+    private clientPromise?;
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    constructor(config: MistralProviderConfig);
+    /**
+     * Loads the Mistral client on first use.
+     */
+    private getClient;
+    complete(messages: ChatMessage[], schema?: JsonSchema): Promise<ReasonerResult>;
+}
+/**
+ * Creates a provider-specific reasoner.
+ * @param config - provider configuration
+ * @returns a reasoner for the selected provider
+ */
+export declare function createReasoner(config: LLMProviderConfig): BaseReasoner;
+export {};