feat: compile calls in a friendlier way

Additionally, this change adds a "call stack" that a caller can use to
get a stack-like data structure for the calls in a run.

Author: thedadams

src/gptscript.ts

@@ -214,7 +214,7 @@ export class Run {
 	public readonly filePath: string
 	public readonly content: string
 	public state: RunState = RunState.Creating
-	public calls: CallFrame[] = []
+	public calls: Record<string, CallFrame> = {}
 	public err: string = ""
 
 	protected stdout?: string
@@ -226,6 +226,10 @@ export class Run {
 	private stderr?: string
 	private callbacks: Record<string, ((f: Frame) => void)[]> = {}
 	private chatState?: string
+	private callIdsByParentIds: Record<string, string[]> = {}
+	private parentCallId: string = ""
+	private prg?: Program
+	private respondingToolId?: string
 
 	constructor(subCommand: string, path: string, content: string, opts: RunOpts, gptscriptURL?: string) {
 		this.id = randomId("run-")
@@ -279,6 +283,7 @@ export class Run {
 		if (out.done === undefined || !out.done) {
 			this.chatState = JSON.stringify(out.state)
 			this.state = RunState.Continue
+			this.respondingToolId = out.toolId
 		} else {
 			this.state = RunState.Finished
 			this.chatState = undefined
@@ -412,7 +417,87 @@ export class Run {
 		}
 	}
 
-	emitEvent(data: string): string {
+	public on(event: RunEventType.RunStart | RunEventType.RunFinish, listener: (data: RunFrame) => void): this;
+	public on(event: RunEventType.CallStart | RunEventType.CallProgress | RunEventType.CallContinue | RunEventType.CallChat | RunEventType.CallConfirm | RunEventType.CallFinish, listener: (data: CallFrame) => void): this;
+	public on(event: RunEventType.Prompt, listener: (data: PromptFrame) => void): this;
+	public on(event: RunEventType.Event, listener: (data: Frame) => void): this;
+	public on(event: RunEventType, listener: (data: any) => void): this {
+		if (!this.callbacks[event]) {
+			this.callbacks[event] = []
+		}
+
+		this.callbacks[event].push(listener)
+
+		return this
+	}
+
+	public text(): Promise<string> {
+		if (this.err) {
+			throw new Error(this.err)
+		}
+
+		if (!this.promise) {
+			throw new Error("Run not started")
+		}
+
+		return this.promise
+	}
+
+	public async json(): Promise<any> {
+		return JSON.parse(await this.text())
+	}
+
+	public currentChatState(): string | undefined {
+		return this.chatState
+	}
+
+	public firstCallId(): string {
+		return this.parentCallId
+	}
+
+	public program(): Program | undefined {
+		return this.prg
+	}
+
+	public respondingTool(): Tool | undefined {
+		return this.respondingToolId ? this.prg?.toolSet[this.respondingToolId] : undefined
+	}
+
+	public callStack(): CallStack {
+		const cs = this.newCallStack("")
+		return cs && cs.length > 0 ? cs[0] : {} as CallStack
+	}
+
+	public close(): void {
+		if (this.req) {
+			this.req.destroy()
+			return
+		}
+		throw new Error("Run not started")
+	}
+
+	private newCallStack(parentID: string): CallStack[] | undefined {
+		if (!this.callIdsByParentIds[parentID]) {
+			return undefined
+		}
+
+		const callStack: CallStack[] = []
+		let callIds = this.callIdsByParentIds[parentID] || []
+		while (callIds.length != 0) {
+			const callId: string = callIds.shift()!
+
+			const cs = {
+				call: this.calls[callId],
+				subCalls: this.newCallStack(callId),
+			} as CallStack
+
+			callStack.push(cs)
+		}
+
+		return callStack
+	}
+
+	private emitEvent(data: string): string {
 		for (let event of data.split("\n")) {
 			event = event.trim()
 
@@ -448,6 +533,7 @@ export class Run {
 
 			if (f.type === RunEventType.RunStart) {
 				this.state = RunState.Running
+				this.prg = f.program
 			} else if (f.type === RunEventType.RunFinish) {
 				if (f.error) {
 					this.state = RunState.Error
@@ -457,14 +543,16 @@ export class Run {
 					this.stdout = f.output || ""
 				}
 			} else if ((f.type as string).startsWith("call")) {
-				f = (f as CallFrame)
-				const idx = this.calls?.findIndex((x) => x.id === f.id)
-
-				if (idx === -1) {
-					this.calls.push(f)
-				} else {
-					this.calls[idx] = f
+				f = f as CallFrame
+				const siblingIds = this.callIdsByParentIds[f.parentID || ""] || []
+				if (siblingIds.findIndex((x) => x === f.id) === -1) {
+					siblingIds.push(f.id)
+					this.callIdsByParentIds[f.parentID || ""] = siblingIds
 				}
+				if (f.parentID === "" && this.parentCallId === "") {
+					this.parentCallId = f.id
+				}
+				this.calls[f.id] = f
 			}
 
 			this.emit(RunEventType.Event, f)
@@ -474,48 +562,6 @@ export class Run {
 		return ""
 	}
 
-	public on(event: RunEventType.RunStart | RunEventType.RunFinish, listener: (data: RunFrame) => void): this;
-	public on(event: RunEventType.CallStart | RunEventType.CallProgress | RunEventType.CallContinue | RunEventType.CallChat | RunEventType.CallConfirm | RunEventType.CallFinish, listener: (data: CallFrame) => void): this;
-	public on(event: RunEventType.Prompt, listener: (data: PromptFrame) => void): this;
-	public on(event: RunEventType.Event, listener: (data: Frame) => void): this;
-	public on(event: RunEventType, listener: (data: any) => void): this {
-		if (!this.callbacks[event]) {
-			this.callbacks[event] = []
-		}
-
-		this.callbacks[event].push(listener)
-
-		return this
-	}
-
-	public text(): Promise<string> {
-		if (this.err) {
-			throw new Error(this.err)
-		}
-
-		if (!this.promise) {
-			throw new Error("Run not started")
-		}
-
-		return this.promise
-	}
-
-	public async json(): Promise<any> {
-		return JSON.parse(await this.text())
-	}
-
-	public currentChatState(): string | undefined {
-		return this.chatState
-	}
-
-	public close(): void {
-		if (this.req) {
-			this.req.destroy()
-			return
-		}
-		throw new Error("Run not started")
-	}
-
 	private emit(event: RunEventType, data: any) {
 		for (const cb of this.callbacks[event] || []) {
 			cb(data)
@@ -556,7 +602,7 @@ export interface ArgumentSchema {
 
 export interface Program {
 	name: string
-	blocks: Block[]
+	toolSet: Record<string, Tool>
 	openAPICache: Record<string, any>
 }
 
@@ -708,6 +754,11 @@ export interface PromptResponse {
 	responses: Record<string, string>
 }
 
+export interface CallStack {
+	call: CallFrame
+	subCalls: CallStack[]
+}
+
 function getCmdPath(): string {
 	if (process.env.GPTSCRIPT_BIN) {
 		return process.env.GPTSCRIPT_BIN

tests/gptscript.test.ts

@@ -203,6 +203,38 @@ describe("gptscript module", () => {
 		}, 30000)
 	})
 
+	test("simple call stack", async () => {
+		const t0 = {
+			tools: ["ask"],
+			instructions: "Only use the ask tool to ask who was the president of the united states in 1928?"
+		}
+		const t1 = {
+			name: "ask",
+			description: "This tool is used to ask a question",
+			arguments: {
+				type: "object",
+				question: "The question to ask"
+			},
+			instructions: "${question}"
+		}
+
+		const run = await client.evaluate([t0 as any, t1 as any])
+		const response = await run.text()
+		expect(response).toBeDefined()
+
+		const cs = run.callStack()
+
+		expect(cs.call).toBeDefined()
+		expect(cs.call.id).toBeDefined()
+		expect(cs.subCalls).toBeDefined()
+		expect(cs.subCalls.length).toEqual(1)
+		expect(cs.subCalls[0].call.parentID).toEqual(cs.call.id)
+		expect(cs.subCalls[0].call.tool).toBeDefined()
+		expect(cs.subCalls[0].call.tool?.name).toEqual("ask")
+		expect(cs.subCalls[0].subCalls).toBeUndefined()
+
+	}, 30000)
+
 	test("parse file", async () => {
 		const response = await client.parse(path.join(__dirname, "fixtures", "test.gpt"))
 		expect(response).toBeDefined()