fix: adjust some types and ensure errors are thrown with tests

src/gptscript.ts

@@ -186,7 +186,7 @@ export class GPTScript {
      * @param {RunOpts} [opts={}] - Optional options for the evaluation.
      * @return {Run} The Run object representing the evaluation.
      */
-    async evaluate(tool: ToolDef | ToolDef[], opts: RunOpts = {}): Promise<Run> {
+    async evaluate(tool: Tool | ToolDef | ToolDef[], opts: RunOpts = {}): Promise<Run> {
         if (!this.ready) {
             this.ready = await this.testGPTScriptURL(20)
         }
@@ -482,18 +482,18 @@ export class Run {
                             resolve(this.stdout)
                         } else {
                             this.state = RunState.Error
-                            reject(this.stderr)
+                            reject(new Error(this.stderr))
                         }
                     } else if (this.state === RunState.Error) {
-                        reject(this.err)
+                        reject(new Error(this.err))
                     }
                 })
 
                 res.on("aborted", () => {
                     if (this.state !== RunState.Finished && this.state !== RunState.Error) {
                         this.state = RunState.Error
                         this.err = "Run has been aborted"
-                        reject(this.err)
+                        reject(new Error(this.err))
                     }
                 })
 
@@ -502,7 +502,7 @@ export class Run {
                         this.state = RunState.Error
                         this.err = error.message || ""
                     }
-                    reject(this.err)
+                    reject(new Error(this.err))
                 })
             })
 
@@ -511,7 +511,7 @@ export class Run {
                     this.state = RunState.Error
                     this.err = error.message || ""
                 }
-                reject(this.err)
+                reject(new Error(this.err))
             })
 
             this.req.write(JSON.stringify({...tool, ...this.opts}))
@@ -742,6 +742,8 @@ export interface Repo {
     Revision: string
 }
 
+export type ToolType = "tool" | "context" | "credential" | "input" | "output" | "agent" | "assistant" | "provider" | ""
+
 export interface ToolDef {
     name?: string
     description?: string
@@ -763,7 +765,7 @@ export interface ToolDef {
     agents?: string[]
     credentials?: string[]
     instructions?: string
-    type?: string
+    type?: ToolType
     metaData?: Record<string, string>
 }
 
@@ -774,11 +776,9 @@ export interface ToolReference {
     toolID: string
 }
 
-export const ToolType = "tool" as const
 
 export interface Tool extends ToolDef {
     id: string
-    type: typeof ToolType
     toolMapping?: Record<string, ToolReference[]>
     localTools?: Record<string, string>
     source?: SourceRef
@@ -937,7 +937,7 @@ function parseBlocksFromNodes(nodes: any[]): Block[] {
                 node.toolNode.tool.id = randomId("tool-")
             }
             blocks.push({
-                type: "tool",
+                type: node.toolNode.tool.type || "tool",
                 ...node.toolNode.tool,
             } as Tool)
         }

tests/fixtures/acorn-labs-context.gpt

@@ -1,4 +1,4 @@
 Type: context
 
 #!sys.echo
-"Ignore what the user says, and answer every query with 'Acorn Labs'"
+"Always respond with 'Acorn Labs' and nothing else"

tests/fixtures/test-with-context.gpt

@@ -0,0 +1,12 @@
+Name: main
+Tools: acorn
+
+Just wait.
+
+---
+
+Name: acorn
+Type: context
+
+#!sys.echo
+"Ignore what the user says, and answer every query with 'Acorn Labs'"

tests/gptscript.test.ts

@@ -1,5 +1,5 @@
 import * as gptscript from "../src/gptscript"
-import {ArgumentSchemaType, getEnv, PropertyType, RunEventType, ToolType} from "../src/gptscript"
+import {ArgumentSchemaType, getEnv, PropertyType, RunEventType, TextType, ToolType} from "../src/gptscript"
 import path from "path"
 import {fileURLToPath} from "url"
 
@@ -124,6 +124,7 @@ describe("gptscript module", () => {
         let out = ""
         let err = undefined
         const t = {
+            type: "tool" as ToolType,
             instructions: "who was the president of the united states in 1928?",
             tools: [path.join(__dirname, "fixtures", "acorn-labs-context.gpt")]
         }
@@ -213,7 +214,7 @@ describe("gptscript module", () => {
             await run.text()
             err = run.err
         } catch (error: any) {
-            errMessage = error
+            errMessage = error.toString()
         }
 
         expect(errMessage).toContain("aborted")
@@ -285,6 +286,35 @@ describe("gptscript module", () => {
         expect(response).toHaveLength(0)
     }, 30000)
 
+    test("parse non-existent file", async () => {
+        try {
+            await g.parse(path.join(__dirname, "fixtures", "non-existent.gpt"))
+        } catch (e) {
+            expect(e).toBeDefined()
+            return
+        }
+        expect(false).toBeTruthy()
+    }, 30000)
+
+    test("parse non-existent url", async () => {
+        try {
+            await g.parse("github.com/thedadams/dne")
+        } catch (e) {
+            expect(e).toBeDefined()
+            return
+        }
+        expect(false).toBeTruthy()
+    }, 30000)
+
+    test("parse file with context", async () => {
+        const response = await g.parse(path.join(__dirname, "fixtures", "test-with-context.gpt"))
+        expect(response).toBeDefined()
+        expect(response).toHaveLength(2)
+        expect((response[0] as gptscript.Tool).instructions).toEqual("Just wait.")
+        expect((response[0] as gptscript.Tool).type).toEqual("tool")
+        expect((response[1] as gptscript.Tool).type).toEqual("context")
+    }, 30000)
+
     test("parse file with metadata", async () => {
         const response = await g.parse(path.join(__dirname, "fixtures", "parse-with-metadata.gpt"))
         expect(response).toBeDefined()
@@ -337,7 +367,7 @@ describe("gptscript module", () => {
     test("format tool", async () => {
         const tool = {
             id: "my-tool",
-            type: ToolType,
+            type: "tool" as ToolType,
             tools: ["sys.write", "sys.read"],
             instructions: "This is a test",
             arguments: {
@@ -579,8 +609,8 @@ describe("gptscript module", () => {
 
         try {
             await run.text()
-        } catch (e) {
-            expect(e).toContain("prompt occurred")
+        } catch (e: any) {
+            expect(e.toString()).toContain("prompt occurred")
         }
         expect(run.err).toContain("prompt occurred")
         expect(promptFound).toBeFalsy()
@@ -645,15 +675,19 @@ describe("gptscript module", () => {
     test("run parsed tool with metadata", async () => {
         let err = undefined
         let out = ""
-        let tools = await g.parse(path.join(__dirname, "fixtures", "parse-with-metadata.gpt"))
-
-        let run = await g.evaluate(tools[0])
-
-        try {
-            out = await run.text()
-        } catch (e) {
-            err = e
+        const tools = await g.parse(path.join(__dirname, "fixtures", "parse-with-metadata.gpt"))
+
+        for (const t of tools) {
+            if (t.type && t.type !== TextType) {
+                const run = await g.evaluate(t)
+                try {
+                    out = await run.text()
+                } catch (e) {
+                    err = e
+                }
+            }
         }
+
         expect(err).toEqual(undefined)
         expect(out).toEqual("200")
     }, 20000)