mdi-llmkit 0.1.0

package/README.md

@@ -0,0 +1,108 @@
+# mdi-llmkit (TypeScript)
+
+Utilities for managing LLM chat conversations and structured JSON responses with OpenAI's Responses API.
+
+## Installation
+
+```bash
+npm install mdi-llmkit openai
+```
+
+## Quick Start
+
+### `gptSubmit`
+
+```ts
+import OpenAI from "openai";
+import { gptSubmit } from "mdi-llmkit";
+
+const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const reply = await gptSubmit(
+	[{ role: "user", content: "Say hello." }],
+	client,
+);
+
+console.log(reply);
+```
+
+### `GptConversation`
+
+```ts
+import OpenAI from "openai";
+import { GptConversation } from "mdi-llmkit";
+
+const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+const conversation = new GptConversation([], { openaiClient: client });
+
+const reply = await conversation.submitUserMessage("Give me three project name ideas.");
+console.log(reply);
+```
+
+### `JSONSchemaFormat`
+
+```ts
+import { JSONSchemaFormat, JSON_INTEGER, gptSubmit } from "mdi-llmkit";
+
+const responseFormat = JSONSchemaFormat(
+	{
+		answer: "The final answer",
+		confidence: ["Confidence score", [0, 100], []],
+		rank: JSON_INTEGER,
+	},
+	{
+		name: "answer_payload",
+		description: "Structured answer payload",
+	},
+);
+
+const result = await gptSubmit(
+	[{ role: "user", content: "Return answer as structured JSON." }],
+	client,
+	{ jsonResponse: responseFormat },
+);
+```
+
+## JSON Response Mode
+
+```ts
+import OpenAI from "openai";
+import { gptSubmit } from "mdi-llmkit";
+
+const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const result = await gptSubmit(
+	[{ role: "user", content: "Return JSON with keys a and b." }],
+	client,
+	{ jsonResponse: true },
+);
+
+console.log(result);
+```
+
+## Notes
+
+- Current TypeScript parity slices include `gptSubmit`, `GptConversation`, and `JSONSchemaFormat`.
+- Integer schemas can be expressed with `JSON_INTEGER`; numeric (float-capable) schemas can use `JSON_NUMBER`.
+
+## Migration from Python
+
+- Function naming: Python `gpt_submit(...)` maps to TypeScript `gptSubmit(...)`.
+- Argument style: Python keyword args map to a TypeScript options object.
+- Conversation submit methods: Python `submit_user_message(...)` maps to `submitUserMessage(...)`.
+- JSON schema DSL: Python tuple metadata uses TypeScript array metadata.
+	- Python: `("Age", (0, 120), int)`
+	- TypeScript: `["Age", [0, 120], JSON_INTEGER]`
+- JSON schema type markers in TypeScript:
+	- `JSON_INTEGER` for integer-only values.
+	- `JSON_NUMBER` for float-capable numeric values.
+
+## CI and Release
+
+- CI workflow: `.github/workflows/typescript-ci.yml`
+	- Runs on push to `main` and on pull requests when TypeScript package files change.
+	- Executes `npm ci`, `npm test`, and `npm run build` in `packages/typescript-mdi-llmkit`.
+- Release workflow: `.github/workflows/typescript-release.yml`
+	- Runs on tags matching `typescript-v*` (for example: `typescript-v0.1.0`).
+	- Requires repository secret `NPM_TOKEN` with publish permission to npm.
+	- Executes tests/build before `npm publish --access public --provenance`.

package/dist/gpt_api/functions.d.ts

@@ -0,0 +1,25 @@
+export declare const GPT_MODEL_CHEAP = "gpt-4.1-nano";
+export declare const GPT_MODEL_SMART = "gpt-4.1";
+export interface OpenAIClientLike {
+    responses: {
+        create: (args: {
+            model: string;
+            input: unknown[];
+            text?: Record<string, unknown>;
+        }) => Promise<any> | any;
+    };
+}
+export interface SystemMessage {
+    role: "system";
+    content: string;
+}
+export interface GptSubmitOptions {
+    model?: string;
+    jsonResponse?: boolean | Record<string, unknown> | string;
+    systemAnnouncementMessage?: string;
+    retryLimit?: number;
+    retryBackoffTimeSeconds?: number;
+    warningCallback?: (message: string) => void;
+}
+export declare function currentDatetimeSystemMessage(): SystemMessage;
+export declare function gptSubmit(messages: unknown[], openaiClient: OpenAIClientLike, options?: GptSubmitOptions): Promise<string | Record<string, unknown> | unknown[] | number | boolean | null>;

package/dist/gpt_api/functions.js

@@ -0,0 +1,193 @@
+export const GPT_MODEL_CHEAP = "gpt-4.1-nano";
+export const GPT_MODEL_SMART = "gpt-4.1";
+const GPT_RETRY_LIMIT_DEFAULT = 5;
+const GPT_RETRY_BACKOFF_TIME_SECONDS_DEFAULT = 30;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseFirstJsonValue(input) {
+    const text = input.trimStart();
+    if (!text) {
+        throw new SyntaxError("Unexpected end of JSON input");
+    }
+    const first = text[0];
+    if (first === "{" || first === "[") {
+        const closing = first === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (inString) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (char === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === '"') {
+                inString = true;
+                continue;
+            }
+            if (char === first) {
+                depth += 1;
+            }
+            else if (char === closing) {
+                depth -= 1;
+                if (depth === 0) {
+                    return JSON.parse(text.slice(0, index + 1));
+                }
+            }
+        }
+        throw new SyntaxError("Unexpected end of JSON input");
+    }
+    if (first === '"') {
+        let escaped = false;
+        for (let index = 1; index < text.length; index += 1) {
+            const char = text[index];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                return JSON.parse(text.slice(0, index + 1));
+            }
+        }
+        throw new SyntaxError("Unexpected end of JSON input");
+    }
+    if (text.startsWith("true")) {
+        return true;
+    }
+    if (text.startsWith("false")) {
+        return false;
+    }
+    if (text.startsWith("null")) {
+        return null;
+    }
+    const numberMatch = text.match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+    if (numberMatch) {
+        return JSON.parse(numberMatch[0]);
+    }
+    throw new SyntaxError("Unexpected token in JSON input");
+}
+function isRetryableOpenAIError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const name = error.name || "";
+    return name.includes("OpenAI") || name.includes("APIError");
+}
+export function currentDatetimeSystemMessage() {
+    const now = new Date();
+    const pad = (value) => value.toString().padStart(2, "0");
+    const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ` +
+        `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+    return {
+        role: "system",
+        content: `!DATETIME: The current date and time is ${timestamp}`,
+    };
+}
+export async function gptSubmit(messages, openaiClient, options = {}) {
+    const model = options.model || GPT_MODEL_SMART;
+    const retryLimit = options.retryLimit ?? GPT_RETRY_LIMIT_DEFAULT;
+    const retryBackoffTimeSeconds = options.retryBackoffTimeSeconds ?? GPT_RETRY_BACKOFF_TIME_SECONDS_DEFAULT;
+    let failedError = null;
+    let openaiTextParam;
+    if (options.jsonResponse) {
+        if (typeof options.jsonResponse === "boolean") {
+            openaiTextParam = { format: { type: "json_object" } };
+        }
+        else if (typeof options.jsonResponse === "string") {
+            openaiTextParam = JSON.parse(options.jsonResponse);
+        }
+        else if (isRecord(options.jsonResponse)) {
+            openaiTextParam = JSON.parse(JSON.stringify(options.jsonResponse));
+            const format = openaiTextParam.format;
+            if (isRecord(format) && typeof format.description === "string") {
+                format.description =
+                    `${format.description}\n\nABSOLUTELY NO UNICODE ALLOWED. ` +
+                        `Only use typeable keyboard characters. Do not try to circumvent this rule ` +
+                        `with escape sequences, backslashes, or other tricks. Use double dashes (--), ` +
+                        `straight quotes (") and single quotes (') instead of em-dashes, en-dashes, ` +
+                        `and curly versions.`.trim();
+            }
+        }
+    }
+    const filteredMessages = messages.filter((message) => {
+        if (!isRecord(message)) {
+            return true;
+        }
+        const role = message.role;
+        const content = message.content;
+        return !(role === "system" &&
+            typeof content === "string" &&
+            content.startsWith("!DATETIME:"));
+    });
+    let preparedMessages = [currentDatetimeSystemMessage(), ...filteredMessages];
+    if (options.systemAnnouncementMessage && options.systemAnnouncementMessage.trim()) {
+        preparedMessages = [
+            { role: "system", content: options.systemAnnouncementMessage.trim() },
+            ...preparedMessages,
+        ];
+    }
+    for (let index = 0; index < retryLimit; index += 1) {
+        let llmReply = "";
+        try {
+            const payload = {
+                model,
+                input: preparedMessages,
+            };
+            if (openaiTextParam) {
+                payload.text = openaiTextParam;
+            }
+            const llmResponse = await openaiClient.responses.create(payload);
+            if (llmResponse.error && options.warningCallback) {
+                options.warningCallback(`ERROR: OpenAI API returned an error: ${llmResponse.error}`);
+            }
+            if (llmResponse.incomplete_details && options.warningCallback) {
+                options.warningCallback(`ERROR: OpenAI API returned incomplete details: ${llmResponse.incomplete_details}`);
+            }
+            llmReply = llmResponse.output_text.trim();
+            if (!options.jsonResponse) {
+                return `${llmReply}`;
+            }
+            return parseFirstJsonValue(llmReply);
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                failedError = error;
+                if (options.warningCallback) {
+                    options.warningCallback(`JSON decode error:\n\n${error}.\n\nRaw text of LLM Reply:\n${llmReply}\n\nRetrying (attempt ${index + 1} of ${retryLimit}) immediately...`);
+                }
+                continue;
+            }
+            if (isRetryableOpenAIError(error)) {
+                failedError = error;
+                if (options.warningCallback) {
+                    options.warningCallback(`OpenAI API error:\n\n${error}.\n\nRetrying (attempt ${index + 1} of ${retryLimit}) in ${retryBackoffTimeSeconds} seconds...`);
+                }
+                await sleep(retryBackoffTimeSeconds * 1000);
+                continue;
+            }
+            throw error;
+        }
+    }
+    if (failedError) {
+        throw failedError;
+    }
+    throw new Error("Unknown error occurred in gptSubmit");
+}

package/dist/gpt_api/gpt_conversation.d.ts

@@ -0,0 +1,43 @@
+import { type OpenAIClientLike } from "./functions.js";
+export interface ConversationMessage {
+    role: string;
+    content: string;
+}
+export interface GptConversationOptions {
+    openaiClient?: OpenAIClientLike;
+    model?: string;
+}
+export interface SubmitOptions {
+    model?: string;
+    jsonResponse?: boolean | Record<string, unknown> | string;
+}
+export declare class GptConversation extends Array<ConversationMessage> {
+    #private;
+    static get [Symbol.species](): ArrayConstructor;
+    get openaiClient(): OpenAIClientLike | undefined;
+    set openaiClient(value: OpenAIClientLike | undefined);
+    get model(): string | undefined;
+    set model(value: string | undefined);
+    get lastReply(): unknown;
+    set lastReply(value: unknown);
+    constructor(messages?: ConversationMessage[], options?: GptConversationOptions);
+    assignMessages(messages?: ConversationMessage[]): this;
+    clone(): GptConversation;
+    submit(message?: string | Record<string, unknown>, role?: string | null, options?: SubmitOptions): Promise<unknown>;
+    addMessage(role: string, content: unknown): this;
+    addUserMessage(content: unknown): this;
+    addAssistantMessage(content: unknown): this;
+    addSystemMessage(content: unknown): this;
+    addDeveloperMessage(content: unknown): this;
+    submitMessage(role: string, content: unknown): Promise<unknown>;
+    submitUserMessage(content: unknown): Promise<unknown>;
+    submitAssistantMessage(content: unknown): Promise<unknown>;
+    submitSystemMessage(content: unknown): Promise<unknown>;
+    submitDeveloperMessage(content: unknown): Promise<unknown>;
+    getLastMessage(): ConversationMessage | null;
+    getMessagesByRole(role: string): ConversationMessage[];
+    getLastReplyStr(): string;
+    getLastReplyDict(): Record<string, unknown>;
+    getLastReplyDictField(fieldName: string, defaultValue?: unknown): unknown;
+    toDictList(): ConversationMessage[];
+}

package/dist/gpt_api/gpt_conversation.js

@@ -0,0 +1,146 @@
+import { GPT_MODEL_SMART, gptSubmit } from "./functions.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export class GptConversation extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    #openaiClient;
+    #model;
+    #lastReply = null;
+    get openaiClient() {
+        return this.#openaiClient;
+    }
+    set openaiClient(value) {
+        this.#openaiClient = value;
+    }
+    get model() {
+        return this.#model;
+    }
+    set model(value) {
+        this.#model = value;
+    }
+    get lastReply() {
+        return this.#lastReply;
+    }
+    set lastReply(value) {
+        this.#lastReply = value;
+    }
+    constructor(messages = [], options = {}) {
+        super(...messages);
+        this.#openaiClient = options.openaiClient;
+        this.#model = options.model;
+    }
+    assignMessages(messages) {
+        this.length = 0;
+        if (messages?.length) {
+            this.push(...messages);
+        }
+        return this;
+    }
+    clone() {
+        return new GptConversation(JSON.parse(JSON.stringify([...this])), {
+            openaiClient: this.openaiClient,
+            model: this.model,
+        });
+    }
+    async submit(message, role = "user", options = {}) {
+        if (!this.openaiClient) {
+            throw new Error("OpenAI client is not set. Please provide an OpenAI client.");
+        }
+        const model = options.model || this.model || GPT_MODEL_SMART;
+        let jsonResponse = options.jsonResponse;
+        if (message) {
+            if (isRecord(message)) {
+                if (!jsonResponse && "format" in message) {
+                    jsonResponse = message;
+                }
+                if (!role && typeof message.role === "string") {
+                    role = message.role;
+                }
+                if ("content" in message) {
+                    message = String(message.content ?? "");
+                }
+            }
+            this.addMessage(role || "user", message);
+        }
+        const llmReply = await gptSubmit(this.toDictList(), this.openaiClient, {
+            jsonResponse,
+            model,
+        });
+        this.addAssistantMessage(llmReply);
+        this.lastReply = llmReply;
+        return llmReply;
+    }
+    addMessage(role, content) {
+        let normalizedContent;
+        if (typeof content === "string") {
+            normalizedContent = content;
+        }
+        else if (isRecord(content)) {
+            normalizedContent = JSON.stringify(content, null, 2);
+        }
+        else {
+            normalizedContent = String(content);
+        }
+        this.push({ role, content: normalizedContent });
+        return this;
+    }
+    addUserMessage(content) {
+        return this.addMessage("user", content);
+    }
+    addAssistantMessage(content) {
+        return this.addMessage("assistant", content);
+    }
+    addSystemMessage(content) {
+        return this.addMessage("system", content);
+    }
+    addDeveloperMessage(content) {
+        return this.addMessage("developer", content);
+    }
+    async submitMessage(role, content) {
+        this.addMessage(role, content);
+        return this.submit();
+    }
+    async submitUserMessage(content) {
+        this.addUserMessage(content);
+        return this.submit();
+    }
+    async submitAssistantMessage(content) {
+        this.addAssistantMessage(content);
+        return this.submit();
+    }
+    async submitSystemMessage(content) {
+        this.addSystemMessage(content);
+        return this.submit();
+    }
+    async submitDeveloperMessage(content) {
+        this.addDeveloperMessage(content);
+        return this.submit();
+    }
+    getLastMessage() {
+        return this.length ? this[this.length - 1] : null;
+    }
+    getMessagesByRole(role) {
+        return this.filter((message) => message.role === role);
+    }
+    getLastReplyStr() {
+        return typeof this.lastReply === "string" ? this.lastReply : "";
+    }
+    getLastReplyDict() {
+        if (!isRecord(this.lastReply)) {
+            return {};
+        }
+        return JSON.parse(JSON.stringify(this.lastReply));
+    }
+    getLastReplyDictField(fieldName, defaultValue = null) {
+        if (!isRecord(this.lastReply)) {
+            return null;
+        }
+        return this.lastReply[fieldName] ?? defaultValue;
+    }
+    toDictList() {
+        return [...this];
+    }
+}

package/dist/gpt_api/json_schema_format.d.ts

@@ -0,0 +1,18 @@
+export declare const JSON_INTEGER: unique symbol;
+export declare const JSON_NUMBER: unique symbol;
+export declare const JSON_STRING: StringConstructor;
+export declare const JSON_BOOLEAN: BooleanConstructor;
+export interface JSONSchemaFormatOptions {
+    name?: string;
+    description?: string;
+}
+export interface JSONSchemaFormatResult {
+    format: {
+        type: "json_schema";
+        strict: true;
+        name?: string;
+        description?: string;
+        schema: Record<string, unknown>;
+    };
+}
+export declare function JSONSchemaFormat(schema: unknown, options?: JSONSchemaFormatOptions): JSONSchemaFormatResult;

package/dist/gpt_api/json_schema_format.js

@@ -0,0 +1,195 @@
+export const JSON_INTEGER = Symbol("JSON_INTEGER");
+export const JSON_NUMBER = Symbol("JSON_NUMBER");
+export const JSON_STRING = String;
+export const JSON_BOOLEAN = Boolean;
+const TYPEMAP = new Map([
+    [JSON_STRING, "string"],
+    [JSON_INTEGER, "integer"],
+    [JSON_NUMBER, "number"],
+    [JSON_BOOLEAN, "boolean"],
+    [String, "string"],
+    [Boolean, "boolean"],
+    [BigInt, "integer"],
+    [Number, "number"],
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isNumericRangeArray(value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        return false;
+    }
+    const [min, max] = value;
+    const minValid = min === null || typeof min === "number";
+    const maxValid = max === null || typeof max === "number";
+    return minValid && maxValid && (typeof min === "number" || typeof max === "number");
+}
+function isTupleMetadataArray(value) {
+    if (!Array.isArray(value) || value.length < 2) {
+        return false;
+    }
+    if (isStringArray(value)) {
+        return false;
+    }
+    return value.some((item) => typeof item === "string" || isNumericRangeArray(item));
+}
+function inferPrimitiveType(schemaValue) {
+    const direct = TYPEMAP.get(schemaValue);
+    if (direct) {
+        return direct;
+    }
+    if (typeof schemaValue === "string") {
+        return "string";
+    }
+    if (typeof schemaValue === "boolean") {
+        return "boolean";
+    }
+    if (typeof schemaValue === "bigint") {
+        return "integer";
+    }
+    if (typeof schemaValue === "number") {
+        return Number.isInteger(schemaValue) ? "integer" : "number";
+    }
+    return null;
+}
+function convertSchemaRecursive(subschema) {
+    let subschemaDescription = "";
+    let subschemaEnum = [];
+    let subschemaNumrange = [null, null];
+    let subschemaValue = subschema;
+    if (isTupleMetadataArray(subschema)) {
+        for (const item of subschema) {
+            if (!item) {
+                subschemaValue = item;
+                continue;
+            }
+            if (typeof item === "string") {
+                subschemaDescription = item;
+                continue;
+            }
+            if (isStringArray(item) && item.length >= 2) {
+                subschemaEnum = item;
+                continue;
+            }
+            if (isNumericRangeArray(item)) {
+                subschemaNumrange = item;
+                continue;
+            }
+            subschemaValue = item;
+        }
+    }
+    if ((Array.isArray(subschemaValue) && isTupleMetadataArray(subschemaValue)) ||
+        (Array.isArray(subschemaValue) && subschemaValue.length === 0)) {
+        if (subschemaEnum.length > 0) {
+            subschemaValue = JSON_STRING;
+        }
+        const [nr0, nr1] = subschemaNumrange;
+        if (nr0 !== null || nr1 !== null) {
+            if ((typeof nr0 === "number" && !Number.isInteger(nr0)) || (typeof nr1 === "number" && !Number.isInteger(nr1))) {
+                subschemaValue = JSON_NUMBER;
+            }
+            else {
+                subschemaValue = JSON_INTEGER;
+            }
+        }
+    }
+    const result = {};
+    if (isRecord(subschemaValue)) {
+        result.type = "object";
+        if (subschemaDescription) {
+            result.description = subschemaDescription;
+        }
+        result.additionalProperties = false;
+        const keys = Object.keys(subschemaValue);
+        result.required = keys;
+        const properties = {};
+        for (const [key, value] of Object.entries(subschemaValue)) {
+            if (typeof value === "string") {
+                properties[key] = { type: "string", description: value };
+            }
+            else {
+                properties[key] = convertSchemaRecursive(value);
+            }
+        }
+        result.properties = properties;
+    }
+    else if (Array.isArray(subschemaValue)) {
+        if (subschemaValue.length >= 2 && isStringArray(subschemaValue)) {
+            result.type = "string";
+            subschemaEnum = subschemaValue;
+        }
+        else {
+            result.type = "array";
+            if (subschemaDescription) {
+                result.description = subschemaDescription;
+            }
+            if (subschemaNumrange[0] !== null) {
+                result.minItems = subschemaNumrange[0];
+            }
+            if (subschemaNumrange[1] !== null) {
+                result.maxItems = subschemaNumrange[1];
+            }
+            const arrayExemplar = subschemaValue[0];
+            if (typeof arrayExemplar === "string") {
+                result.items = { type: "string", description: arrayExemplar };
+            }
+            else {
+                result.items = convertSchemaRecursive(arrayExemplar);
+            }
+        }
+    }
+    else {
+        const primitiveType = inferPrimitiveType(subschemaValue);
+        if (!primitiveType) {
+            throw new Error(`Unrecognized type for schema value: ${String(subschemaValue)}`);
+        }
+        result.type = primitiveType;
+        if (subschemaDescription) {
+            result.description = subschemaDescription;
+        }
+    }
+    if (subschemaEnum.length) {
+        result.enum = subschemaEnum;
+    }
+    if (result.type === "integer" || result.type === "number") {
+        if (subschemaNumrange[0] !== null) {
+            result.minimum = subschemaNumrange[0];
+        }
+        if (subschemaNumrange[1] !== null) {
+            result.maximum = subschemaNumrange[1];
+        }
+    }
+    return result;
+}
+export function JSONSchemaFormat(schema, options = {}) {
+    const result = {
+        format: {
+            type: "json_schema",
+            strict: true,
+            schema: { type: "object", properties: {}, required: [], additionalProperties: false },
+        },
+    };
+    if (options.name) {
+        result.format.name = options.name;
+    }
+    if (options.description) {
+        result.format.description = options.description;
+    }
+    let converted = convertSchemaRecursive(schema);
+    if (converted.type !== "object") {
+        const wrapperName = options.name || "schema";
+        converted = {
+            type: "object",
+            required: [wrapperName],
+            additionalProperties: false,
+            properties: {
+                [wrapperName]: converted,
+            },
+        };
+    }
+    result.format.schema = converted;
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./gpt_api/functions.js";
+export * from "./gpt_api/gpt_conversation.js";
+export * from "./gpt_api/json_schema_format.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./gpt_api/functions.js";
+export * from "./gpt_api/gpt_conversation.js";
+export * from "./gpt_api/json_schema_format.js";

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "mdi-llmkit",
+  "version": "0.1.0",
+  "description": "Utilities for managing multi-shot conversations and structured data handling in LLM applications",
+  "author": "Mikhail Voloshin",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "keywords": [
+    "llm",
+    "openai",
+    "responses-api",
+    "structured-outputs",
+    "chat"
+  ],
+  "dependencies": {
+    "openai": "^6.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.18.10",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}