Val Town Code SearchReturn to Val Town

94Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
95
96### OpenAI
97
98```ts
99import { OpenAI } from "https://esm.town/v/std/openai";
100const openai = new OpenAI();
101const completion = await openai.chat.completions.create({
102  messages: [
103    { role: "user", content: "Say hello in a creative way" },

1import { OpenAI } from "https://esm.sh/openai@4.85.1";
2import { sqlite } from "https://esm.town/v/std/sqlite";
3
7};
8
9interface ChatOpenAI {
10  invoke(messages: Message[]): Promise<string>;
11}
12
13export function ChatOpenAI(model: string): ChatOpenAI {
14  const openai = new OpenAI();
15
16  return {
17    invoke: async (messages: Message[]): Promise<string> => {
18      const completion = await openai.chat.completions.create({
19        messages: messages.map(message => ({
20          role: message.role as "user" | "assistant" | "system",
29}
30
31// Decorator for ChatOpenAI that will eventually add rate limiting
32export function GlobalRateLimitedChatOpenAI(model: string, requestsPerSecond: number): ChatOpenAI {
33  const openAi = ChatOpenAI(model);
34
35  const rateLimiter = new GlobalRateLimiter(requestsPerSecond);
39      await rateLimiter.check();
40
41      return openAi.invoke(messages);
42    },
43  };

100Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
101
102### OpenAI
103```ts
104import { OpenAI } from "https://esm.town/v/std/openai";
105const openai = new OpenAI();
106const completion = await openai.chat.completions.create({
107  messages: [
108    { role: "user", content: "Say hello in a creative way" },

93Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
94
95### OpenAI
96
97```ts
98import { OpenAI } from "https://esm.town/v/std/openai";
99const openai = new OpenAI();
100const completion = await openai.chat.completions.create({
101  messages: [
102    { role: "user", content: "Say hello in a creative way" },

953// --- Main Request Handler (Server Code - MODIFIED) ---
954export default async function(req: Request) {
955  const { OpenAI } = await import("https://esm.town/v/std/openai");
956  const { fetch } = await import("https://esm.town/v/std/fetch");
957  // PDFExtract is kept if you want to add document features later, but not primary for this use case.
965  const action = url.searchParams.get("action"); // New: "loanAssumptionInfo"
966  const sourceUrl = import.meta.url.replace("esm.town", "val.town");
967  const openai = new OpenAI();
968  const MAX_TEXT_LENGTH_ANALYSIS = 10000; // Reduced as input is smaller now
969
992  }
993
994  // callOpenAI function (same as original, but uses gpt-4o by default)
995  async function callOpenAI(
996    openaiInstance: OpenAI,
997    systemPrompt: string,
998    userMessage: string, // For this app, userMessage to AI might be empty if all info is in systemPrompt
1003  ): Promise<object | string> {
1004    // ... (implementation from original)
1005    log.push({ agent: agentName, type: "step", message: `Calling OpenAI model ${model}...` });
1006    try {
1007      const response = await openaiInstance.chat.completions.create({
1008        model: model,
1009        messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
1124        .replace("%%USER_NAME%%", analysisInput.userName);
1125      // The %%INPUT_SOURCE_DESCRIPTION%% and %%LEGAL_TASK_QUERY%% are not in the new prompt in this direct way.
1126      // The userMessage to openAI can be kept minimal or empty as the system prompt is rich.
1127      const userMessageForAI = ""; // Or analysisInput.documentText if you want to provide more context there.
1128
1129      const analysisAgentName = "HomeAdvantage AI";
1130      const aiResponse = await callOpenAI(
1131        openai,
1132        finalSystemPrompt,
1133        userMessageForAI,

880}
881export default async function(req: Request) {
882  const { OpenAI } = await import("https://esm.town/v/std/openai");
883  const { fetch } = await import("https://esm.town/v/std/fetch");
884  const { PDFExtract, PDFExtractOptions } = await import("npm:pdf.js-extract");
893  const action = url.searchParams.get("action");
894  const sourceUrl = import.meta.url.replace("esm.town", "val.town");
895  const openai = new OpenAI();
896  const MAX_TEXT_LENGTH_SUGGESTION = 20000;
897  const MAX_TEXT_LENGTH_ANALYSIS = 30000;
917    }
918  }
919  async function callOpenAI(
920    openaiInstance: OpenAI,
921    systemPrompt: string,
922    userMessage: string,
926    agentName: string,
927  ): Promise<object | string> {
928    log.push({ agent: agentName, type: "step", message: `Calling OpenAI model ${model}...` });
929    try {
930      const response = await openaiInstance.chat.completions.create({
931        model: model,
932        messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
1092    );
1093    const suggestionAgentName = "Task Suggestion AI";
1094    const suggestionsResponse = await callOpenAI(
1095      openai,
1096      suggestionPrompt,
1097      "",
1212      );
1213      const analysisAgentName = "Legal Analysis AI";
1214      const aiResponse = await callOpenAI(
1215        openai,
1216        finalSystemPrompt,
1217        documentTextToAnalyze,

2 * Legal AI Document Analysis (Single Val Version with PDF Upload & Dashboard Style)
3 * Ingests documents (URL, Text, PDF Upload), takes a user-defined legal task query,
4 * and uses a Legal AI Agent (via OpenAI) to analyze the content.
5 * The Legal AI Agent outputs a standardized JSON structure.
6 * Uses 'npm:pdf.js-extract' for direct PDF text extraction within the Val.
566export default async function(req: Request) {
567  // --- Dynamic Imports (Inside Handler) ---
568  const { OpenAI } = await import("https://esm.town/v/std/openai");
569  const { z } = await import("npm:zod"); // For potential future robust input validation on server
570  const { fetch } = await import("https://esm.town/v/std/fetch");
608  }
609
610  // --- Helper Function: Call OpenAI API ---
611  async function callOpenAI(
612    openai: OpenAI,
613    systemPrompt: string,
614    userMessage: string, // This will be the document text
617  ): Promise<object | string> { // Return type can be object if JSON, or string if error
618    try {
619      const response = await openai.chat.completions.create({
620        model: model,
621        messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
630          return JSON.parse(content);
631        } catch (parseError) {
632          console.error("OpenAI JSON Parse Error:", parseError, "Raw Content:", content);
633          // Return the raw content if parsing fails, for debugging, wrapped as an error object
634          return {
642      }
643    } catch (error) {
644      console.error(`OpenAI API call failed. Error:`, error);
645      let errorMessage = "Error communicating with AI model.";
646      if (error.message) { errorMessage += ` Details: ${error.message}`; }
661    log: LogEntry[],
662  ): Promise<{ finalResult?: LegalAIResponse | object; log: LogEntry[] }> {
663    const openai = new OpenAI(); // Assumes OPENAI_API_KEY is in environment
664
665    log.push({ agent: "System", type: "step", message: "Starting Legal AI analysis workflow." });
756    finalSystemPrompt = finalSystemPrompt.replace("%%INPUT_SOURCE_DESCRIPTION%%", input.inputSourceDescription);
757
758    const aiResponse = await callOpenAI(openai, finalSystemPrompt, truncatedText, "gpt-4o", true); // Expect JSON
759
760    if (typeof aiResponse === "object" && (aiResponse as any).error) {
761      // Error from callOpenAI helper (API or parsing)
762      log.push({
763        agent: "Legal AI Agent",
784      log.push({ agent: "System", type: "final", message: "Workflow finished successfully." });
785      return { finalResult: aiResponse as LegalAIResponse, log };
786    } else { // Should not happen if expectJson is true and no error object from callOpenAI
787      log.push({
788        agent: "Legal AI Agent",

88Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
89
90### OpenAI
91
92```ts
93import { OpenAI } from "https://esm.town/v/std/openai";
94const openai = new OpenAI();
95const completion = await openai.chat.completions.create({
96  messages: [
97    { role: "user", content: "Say hello in a creative way" },

94Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
95
96### OpenAI
97
98```ts
99import { OpenAI } from "https://esm.town/v/std/openai";
100const openai = new OpenAI();
101const completion = await openai.chat.completions.create({
102  messages: [
103    { role: "user", content: "Say hello in a creative way" },

2 * Legal AI Document Analysis (Single Val Version with PDF Upload & Dashboard Style)
3 * Ingests documents (URL, Text, PDF Upload), takes a user-defined legal task query,
4 * and uses a Legal AI Agent (via OpenAI) to analyze the content.
5 * The Legal AI Agent outputs a standardized JSON structure.
6 * Uses 'npm:pdf.js-extract' for direct PDF text extraction within the Val.
813export default async function(req: Request) {
814  // --- Dynamic Imports (Inside Handler) ---
815  const { OpenAI } = await import("https://esm.town/v/std/openai");
816  const { z } = await import("npm:zod"); // For potential future robust input validation on server
817  const { fetch } = await import("https://esm.town/v/std/fetch");
855  }
856
857  // --- Helper Function: Call OpenAI API ---
858  async function callOpenAI(
859    openai: OpenAI,
860    systemPrompt: string,
861    userMessage: string, // This will be the document text
864  ): Promise<object | string> { // Return type can be object if JSON, or string if error
865    try {
866      const response = await openai.chat.completions.create({
867        model: model,
868        messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
877          return JSON.parse(content);
878        } catch (parseError) {
879          console.error("OpenAI JSON Parse Error:", parseError, "Raw Content:", content);
880          // Return the raw content if parsing fails, for debugging, wrapped as an error object
881          return {
889      }
890    } catch (error) {
891      console.error(`OpenAI API call failed. Error:`, error);
892      let errorMessage = "Error communicating with AI model.";
893      if (error.message) { errorMessage += ` Details: ${error.message}`; }
908    log: LogEntry[],
909  ): Promise<{ finalResult?: LegalAIResponse | object; log: LogEntry[] }> {
910    const openai = new OpenAI(); // Assumes OPENAI_API_KEY is in environment
911
912    log.push({ agent: "System", type: "step", message: "Starting Legal AI analysis workflow." });
1003    finalSystemPrompt = finalSystemPrompt.replace("%%INPUT_SOURCE_DESCRIPTION%%", input.inputSourceDescription);
1004
1005    const aiResponse = await callOpenAI(openai, finalSystemPrompt, truncatedText, "gpt-4o", true); // Expect JSON
1006
1007    if (typeof aiResponse === "object" && (aiResponse as any).error) {
1008      // Error from callOpenAI helper (API or parsing)
1009      log.push({
1010        agent: "Legal AI Agent",
1031      log.push({ agent: "System", type: "final", message: "Workflow finished successfully." });
1032      return { finalResult: aiResponse as LegalAIResponse, log };
1033    } else { // Should not happen if expectJson is true and no error object from callOpenAI
1034      log.push({
1035        agent: "Legal AI Agent",