dhti-cli 0.1.0 → 0.1.1

package/dist/commands/mimic.js

@@ -0,0 +1,156 @@
+import { Args, Command } from '@oclif/core';
+export default class Mimic extends Command {
+    static args = {
+        server: Args.string({ default: 'http://localhost/fhir/$import', description: 'Server URL to submit' }), // object with input, instruction (rationale in distillation), output
+    };
+    static description = 'Submit a FHIR request to a server';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const { args, flags } = await this.parse(Mimic);
+        const mimic_request = `{
+
+  "resourceType": "Parameters",
+
+  "parameter": [ {
+
+    "name": "inputFormat",
+
+    "valueCode": "application/fhir+ndjson"
+
+  }, {
+
+    "name": "inputSource",
+
+    "valueUri": "http://example.com/fhir/"
+
+  }, {
+
+    "name": "storageDetail",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "https"
+
+    }, {
+
+      "name": "credentialHttpBasic",
+
+      "valueString": "admin:password"
+
+    }, {
+
+      "name": "maxBatchResourceCount",
+
+      "valueString": "500"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Observation"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/ObservationLabevents.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Medication"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Medication.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Procedure"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Procedure.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Condition"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Condition.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Patient"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Patient.ndjson"
+
+    } ]
+
+  } ]
+
+}`;
+        // send a POST request to the server with the mimic_request body
+        const response = await fetch(args.server, {
+            body: mimic_request,
+            headers: {
+                'Content-Type': 'application/fhir+json',
+                'Prefer': 'respond-async'
+            },
+            method: 'POST',
+        });
+        if (!response.ok) {
+            console.error(`Error: ${response.status} ${response.statusText}`);
+        }
+    }
+}

package/dist/commands/synthetic.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class Synthetic extends Command {
+    static args: {
+        input: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        output: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        prompt: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        inputField: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        maxCycles: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        maxRecords: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        outputField: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/synthetic.js

@@ -0,0 +1,88 @@
+import { Args, Command, Flags } from '@oclif/core';
+import fs from 'node:fs';
+import bootstrap from '../utils/bootstrap.js';
+import { ChainService } from '../utils/chain.js';
+export default class Synthetic extends Command {
+    static args = {
+        input: Args.string({ default: "", description: 'Input file to process' }), // object with input, instruction (rationale in distillation), output
+        output: Args.string({ description: 'Output file to write' }),
+        prompt: Args.string({ default: "", description: 'Prompt file to read' }),
+    };
+    static description = 'Generate synthetic data using LLM';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        inputField: Flags.string({ char: 'i', default: 'input', description: 'Input field to use', options: ['input', 'instruction', 'output'] }),
+        maxCycles: Flags.integer({ char: 'm', default: 0, description: 'Maximum number of cycles to run' }),
+        maxRecords: Flags.integer({ char: 'r', default: 10, description: 'Maximum number of records to generate' }),
+        outputField: Flags.string({ char: 'o', default: 'output', description: 'Output field to use', options: ['input', 'instruction', 'output'] }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Synthetic);
+        let prompt = "";
+        // read prompt file if provided
+        if (args.prompt)
+            prompt = fs.readFileSync(args.prompt ?? '', 'utf8');
+        const container = await bootstrap();
+        const chain = new ChainService(container);
+        // if no output file, exit with error
+        if (!args.output) {
+            console.log("Please provide an output file");
+            this.exit(1);
+        }
+        if (flags.maxCycles) { // No input file, can process in batches
+            const input = {
+                input: prompt,
+            };
+            let responses = [];
+            for (let i = 0; i < flags.maxCycles; i++) {
+                const response = await chain.Chain(input);
+                let cycle = [];
+                const jsonArrayMatch = response.match(/\[[^\]]*]/);
+                if (jsonArrayMatch) {
+                    try {
+                        cycle = JSON.parse(jsonArrayMatch[0]);
+                    }
+                    catch (error) {
+                        console.error('Failed to parse JSON array from response:', error);
+                    }
+                }
+                responses = responses.concat(cycle);
+                console.log(`Iteration ${i + 1}: Collected ${responses.length} records so far, ${flags.maxRecords - responses.length} to go`);
+                if (responses.length >= flags.maxRecords)
+                    break;
+            }
+            // convert to json
+            const jsonOutput = [];
+            for (const response of responses) {
+                jsonOutput.push({
+                    [flags.outputField]: response,
+                });
+            }
+            fs.writeFileSync(args.output ?? '', JSON.stringify(jsonOutput, null, 4));
+            console.log(`${args.output} has been created with ${flags.maxRecords} records`);
+        }
+        else { // Input file, process one by one
+            // read input file
+            const input = JSON.parse(fs.readFileSync(args.input ?? '', 'utf8'));
+            const responses = [];
+            // for each record in input file
+            for (const [i, record] of input.entries()) {
+                const chainInput = {
+                    input: record[flags.inputField],
+                    prompt,
+                };
+                const response = await chain.Chain(chainInput);
+                record[flags.outputField] = response;
+                responses.push(record);
+                if (responses.length >= flags.maxRecords)
+                    break;
+                console.log(`Processed ${i + 1} records so far, ${flags.maxRecords - responses.length} to go`);
+            }
+            // write to output file
+            fs.writeFileSync(args.output ?? '', JSON.stringify(responses, null, 4));
+            console.log(`${args.output} has been created with ${responses.length} records`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils/index.js';
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './utils/index.js';
+export { run } from '@oclif/core';

package/dist/utils/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+declare const bootstrap: () => Promise<import("tsyringe").DependencyContainer>;
+export default bootstrap;

package/dist/utils/bootstrap.js

@@ -0,0 +1,57 @@
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { Ollama } from "@langchain/ollama";
+import "reflect-metadata";
+import { container } from "tsyringe";
+// import { VertexAI } from "@langchain/google-vertexai";
+// import { GoogleVertexAIEmbeddings } from "@langchain/community/embeddings/googlevertexai";
+import { FakeListChatModel } from "@langchain/core/utils/testing";
+const bootstrap = async () => {
+    let main_llm = null;
+    // try{
+    // const vertex = new VertexAI({
+    //     temperature: 0.6,
+    //     maxOutputTokens: 256,
+    //     model: "gemini-pro",
+    // })
+    // main_llm = vertex;
+    // } catch (error) {
+    const ollama = new Ollama({
+        baseUrl: process.env.NEXT_PUBLIC_OLLAMA_URL || "http://localhost:11434",
+        model: process.env.NEXT_PUBLIC_OLLAMA_MODEL || "phi3:mini",
+        numPredict: 128,
+        temperature: 0.6,
+    });
+    const fake_llm = new FakeListChatModel({
+        responses: ["I'll callback later.", "You 'console' them!"],
+    });
+    main_llm = fake_llm;
+    // }
+    // const main_llm = new OllamaFunctions({
+    //     temperature: 0.6,
+    //     model: "phi3:mini",
+    //     numPredict: 32,
+    // });
+    const gen_prompt = ChatPromptTemplate.fromMessages([
+        [
+            "system",
+            "You are a medical doctor.",
+        ],
+        ["human", "{input}"],
+    ]);
+    const instruct_prompt = ChatPromptTemplate.fromMessages([
+        [
+            "system",
+            "You are a HL7 FHIR expert.",
+        ],
+        ["human", "{prompt} {input}"],
+    ]);
+    const prompt = instruct_prompt;
+    container.register("main-llm", {
+        useValue: main_llm,
+    });
+    container.register("prompt", {
+        useValue: prompt,
+    });
+    return container;
+};
+export default bootstrap;

package/dist/utils/card.d.ts

@@ -0,0 +1,58 @@
+/**
+ * TypeScript models for CDS Hook Card
+ *
+ * Example:
+ * {
+ *   "summary": "Patient is at high risk for opioid overdose.",
+ *   "detail": "According to CDC guidelines, the patient's opioid dosage should be tapered to less than 50 MME. [Link to CDC Guideline](https://www.cdc.gov/drugoverdose/prescribing/guidelines.html)",
+ *   "indicator": "warning",
+ *   "source": {
+ *     "label": "CDC Opioid Prescribing Guidelines",
+ *     "url": "https://www.cdc.gov/drugoverdose/prescribing/guidelines.html",
+ *     "icon": "https://example.org/img/cdc-icon.png"
+ *   },
+ *   "links": [
+ *     {
+ *       "label": "View MME Conversion Table",
+ *       "url": "https://www.cdc.gov/drugoverdose/prescribing/mme.html"
+ *     }
+ *   ]
+ * }
+ */
+/**
+ * The allowed indicators for a CDS Hook Card.
+ * Mirrors: Literal["info", "warning", "hard-stop"]
+ */
+export type CDSHookCardIndicator = 'hard-stop' | 'info' | 'warning';
+/**
+ * Source of the CDS Hook Card
+ */
+export declare class CDSHookCardSource {
+    icon?: string;
+    label: string;
+    url?: string;
+    constructor(init?: Partial<CDSHookCardSource>);
+}
+/**
+ * Link associated with the CDS Hook Card
+ */
+export declare class CDSHookCardLink {
+    label: string;
+    url: string;
+    constructor(init?: Partial<CDSHookCardLink>);
+}
+/**
+ * CDS Hook Card Model
+ */
+export declare class CDSHookCard {
+    detail?: string;
+    indicator?: CDSHookCardIndicator;
+    links?: CDSHookCardLink[];
+    source?: CDSHookCardSource;
+    summary: string;
+    constructor(init?: Partial<CDSHookCard>);
+    /**
+     * Factory to build a CDSHookCard from a plain object, ensuring nested types are instantiated.
+     */
+    static from(obj: Partial<CDSHookCard>): CDSHookCard;
+}

package/dist/utils/card.js

@@ -0,0 +1,69 @@
+/**
+ * TypeScript models for CDS Hook Card
+ *
+ * Example:
+ * {
+ *   "summary": "Patient is at high risk for opioid overdose.",
+ *   "detail": "According to CDC guidelines, the patient's opioid dosage should be tapered to less than 50 MME. [Link to CDC Guideline](https://www.cdc.gov/drugoverdose/prescribing/guidelines.html)",
+ *   "indicator": "warning",
+ *   "source": {
+ *     "label": "CDC Opioid Prescribing Guidelines",
+ *     "url": "https://www.cdc.gov/drugoverdose/prescribing/guidelines.html",
+ *     "icon": "https://example.org/img/cdc-icon.png"
+ *   },
+ *   "links": [
+ *     {
+ *       "label": "View MME Conversion Table",
+ *       "url": "https://www.cdc.gov/drugoverdose/prescribing/mme.html"
+ *     }
+ *   ]
+ * }
+ */
+/**
+ * Source of the CDS Hook Card
+ */
+export class CDSHookCardSource {
+    icon;
+    label;
+    url;
+    constructor(init) {
+        Object.assign(this, init);
+    }
+}
+/**
+ * Link associated with the CDS Hook Card
+ */
+export class CDSHookCardLink {
+    label;
+    url;
+    constructor(init) {
+        Object.assign(this, init);
+    }
+}
+/**
+ * CDS Hook Card Model
+ */
+export class CDSHookCard {
+    detail;
+    indicator;
+    links;
+    source;
+    summary;
+    constructor(init) {
+        if (init) {
+            // Shallow assign for primitives; nested objects handled below if present
+            const { links, source, ...rest } = init;
+            Object.assign(this, rest);
+            if (source)
+                this.source = new CDSHookCardSource(source);
+            if (links)
+                this.links = links.map((l) => new CDSHookCardLink(l));
+        }
+    }
+    /**
+     * Factory to build a CDSHookCard from a plain object, ensuring nested types are instantiated.
+     */
+    static from(obj) {
+        return new CDSHookCard(obj);
+    }
+}

package/dist/utils/chain.d.ts

@@ -0,0 +1,5 @@
+export declare class ChainService {
+    container: any;
+    constructor(container: any);
+    Chain(input: any): Promise<string>;
+}

package/dist/utils/chain.js

@@ -0,0 +1,17 @@
+import { StringOutputParser } from "@langchain/core/output_parsers";
+import { RunnablePassthrough, RunnableSequence } from "@langchain/core/runnables";
+export class ChainService {
+    container;
+    constructor(container) {
+        this.container = container;
+    }
+    async Chain(input) {
+        const output = RunnableSequence.from([
+            new RunnablePassthrough(),
+            this.container.resolve("prompt"),
+            this.container.resolve("main-llm"),
+            new StringOutputParser(),
+        ]);
+        return output.invoke(input);
+    }
+}

package/dist/utils/getCard.d.ts

@@ -0,0 +1,3 @@
+import { CDSHookCard } from './card.js';
+declare const cards: (response: any) => CDSHookCard[];
+export default cards;

package/dist/utils/getCard.js

@@ -0,0 +1,11 @@
+import { CDSHookCard } from './card.js';
+const cards = (response) => {
+    const _cards = response?.data?.cards;
+    if (Array.isArray(_cards) && _cards.length > 0) {
+        const lastCard = _cards.at(-1);
+        const card = new CDSHookCard(lastCard);
+        return [card];
+    }
+    return [new CDSHookCard()];
+};
+export default cards;

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './card.js';
+export * from './getCard.js';
+export * from './request.js';
+export * from './useDhti.js';

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export * from './card.js';
+export * from './getCard.js';
+export * from './request.js';
+export * from './useDhti.js';
+// ...add others as needed

package/dist/utils/request.d.ts

@@ -0,0 +1,30 @@
+/**
+ * CDS Hook Request Model (TypeScript)
+ *
+ * Example:
+ * {
+ *   "hookInstance": "d1577c69-dfbe-44ad-ba6d-3e05e953b2ea",
+ *   "fhirServer": "https://example.com/fhir",
+ *   "fhirAuthorization": { ... },
+ *   "hook": "patient-view",
+ *   "context": { ... },
+ *   "prefetch": { ... }
+ * }
+ */
+export declare class CDSHookRequest {
+    /** Context object passed by the EHR */
+    context?: Record<string, any> | null;
+    /** Authorization details (opaque to this model) */
+    fhirAuthorization?: Record<string, any> | null;
+    /** Base URL of the FHIR server associated with the hook */
+    fhirServer?: string;
+    /** Name of the hook (e.g., "patient-view", "order-select", etc.) */
+    hook?: string;
+    /** A unique identifier for this hook invocation */
+    hookInstance?: string;
+    /** Prefetched FHIR resources keyed by name */
+    prefetch?: Record<string, any> | null;
+    constructor(init?: Partial<CDSHookRequest>);
+    /** Factory to build a CDSHookRequest from a plain object. */
+    static from(obj: Partial<CDSHookRequest>): CDSHookRequest;
+}

package/dist/utils/request.js

@@ -0,0 +1,34 @@
+/**
+ * CDS Hook Request Model (TypeScript)
+ *
+ * Example:
+ * {
+ *   "hookInstance": "d1577c69-dfbe-44ad-ba6d-3e05e953b2ea",
+ *   "fhirServer": "https://example.com/fhir",
+ *   "fhirAuthorization": { ... },
+ *   "hook": "patient-view",
+ *   "context": { ... },
+ *   "prefetch": { ... }
+ * }
+ */
+export class CDSHookRequest {
+    /** Context object passed by the EHR */
+    context;
+    /** Authorization details (opaque to this model) */
+    fhirAuthorization;
+    /** Base URL of the FHIR server associated with the hook */
+    fhirServer;
+    /** Name of the hook (e.g., "patient-view", "order-select", etc.) */
+    hook;
+    /** A unique identifier for this hook invocation */
+    hookInstance;
+    /** Prefetched FHIR resources keyed by name */
+    prefetch;
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    /** Factory to build a CDSHookRequest from a plain object. */
+    static from(obj) {
+        return new CDSHookRequest(obj);
+    }
+}

package/dist/utils/useDhti.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sends a CDS Hook Request where the request.context contains the user's input message.
+ */
+declare const handleBundle: (newMessage: string) => Promise<import("axios").AxiosResponse<any, any>>;
+export default handleBundle;

package/dist/utils/useDhti.js

@@ -0,0 +1,21 @@
+import axios from 'axios';
+import { CDSHookRequest } from './request.js';
+/**
+ * Sends a CDS Hook Request where the request.context contains the user's input message.
+ */
+const handleBundle = (newMessage) => {
+    const request = new CDSHookRequest({
+        context: { input: newMessage },
+    });
+    // TODO: Investigate why nested input is required
+    const _request = {
+        input: request,
+    };
+    const endpoint = process.env.LANGSERVE_POST_ENDPOINT || '/langserve/dhti_elixir_template/invoke';
+    return axios.post(endpoint, {
+        config: {},
+        input: _request,
+        kwargs: {},
+    });
+};
+export default handleBundle;