,
+ R extends Returns,
+> = {
+ [K in keyof P]: (
+ params: z.infer,
+ ) => z.infer | Promise>
+}
+
+export const serializableError = z.object({
+ name: z.string().optional(),
+ message: z.string(),
+ stack: z.string().optional(),
+})
+export type SerializableError = z.infer
+
+export const outcomeSchema = z.object({
+ result: jsonSchema.optional(),
+ error: serializableError.optional(),
+}).refine((data) => {
+ if (data.error !== undefined) {
+ return data.result === undefined
+ }
+ return true
+}, 'result and error are mutually exclusive')
+
+export type Outcome = { result?: JsonValue; error?: SerializableError }
+
+export type IoStruct = z.infer
+export const ioStruct = z.object({
+ sequence: sequenceInteger,
+ /** The current sequence of the request being executed serially */
+ executing: sequenceInteger.optional(),
+ /** The sequences of requests that have been executed serially */
+ executed: z.record(sequenceKey, z.boolean()),
+ // TODO make the requests be a zod schema
+ requests: z.record(sequenceKey, requestSchema),
+ replies: z.record(sequenceKey, outcomeSchema),
+ /** If a reply is a merge reply, the commit that carried it is stored here */
+ parents: z.record(sequenceKey, md5),
+ /**
+ * If a request generates child requests, they are tracked here. The commit
+ * in each entry is the commit that caused the child requests to be generated.
+ * This is used to replay by resetting the fs to that commit and doing a
+ * replay.
+ */
+ pendings: z.record(
+ sequenceKey,
+ z.array(z.object({
+ commit: md5,
+ sequences: z.array(sequenceInteger),
+ })),
+ ),
+ /** Active branches are stored here. A branch is a daemon if it is listed
+ * here but its request has been replied to or it is gone from the requests
+ * list */
+ branches: z.record(sequenceKey, z.string()),
+ /**
+ * Isolates can store values here and know they will not leak into other
+ * branches, and will be quick to access since the io file is always loaded.
+ */
+ state: z.record(jsonSchema),
+})
+export const reasoning = z.array(z.string()).describe(
+ 'Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function',
+)
+export type TreeEntry = {
+ /**
+ * - the 6 digit hexadecimal mode
+ */
+ mode: string
+ /**
+ * - the name of the file or directory
+ */
+ path: string
+ /**
+ * - the SHA-1 object id of the blob or tree
+ */
+ oid: string
+ /**
+ * - the type of object
+ */
+ type: 'blob' | 'tree' | 'commit'
+}
+export const pooledRef = z.object({
+ commit: md5,
+ sequence: sequenceInteger,
+ source: pidSchema,
+ isReply: z.boolean(),
+})
+export type PooledRef = z.infer
diff --git a/_import-artifact/api/watcher.ts b/_import-artifact/api/watcher.ts
new file mode 100644
index 000000000000..f1abda3d4219
--- /dev/null
+++ b/_import-artifact/api/watcher.ts
@@ -0,0 +1,88 @@
+import { EngineInterface, IoStruct, isPierceRequest, PID } from './types.ts'
+import { deserializeError } from 'serialize-error'
+
+type PiercePromise = {
+ resolve: (value: unknown) => void
+ reject: (error: Error) => void
+}
+export class PierceWatcher {
+ readonly #pierces = new Map()
+ readonly #engine: EngineInterface
+ readonly #pid: PID
+ readonly #abort = new AbortController()
+ constructor(signal: AbortSignal, engine: EngineInterface, pid: PID) {
+ this.#engine = engine
+ this.#pid = pid
+
+ signal.addEventListener('abort', () => {
+ this.#abort.abort()
+ })
+ engine.abortSignal.addEventListener('abort', () => {
+ this.#abort.abort()
+ })
+ }
+ static create(signal: AbortSignal, engine: EngineInterface, pid: PID) {
+ return new PierceWatcher(signal, engine, pid)
+ }
+ watch(ulid: string) {
+ return new Promise((resolve, reject) => {
+ this.#pierces.set(ulid, { resolve, reject })
+ })
+ }
+ async watchPierces() {
+ let lastSplice
+ const after = undefined
+ const { signal } = this.#abort
+ const s = this.#engine.watch(this.#pid, '.io.json', after, signal)
+ for await (const splice of s) {
+ // move these checks to the engine side
+ if (lastSplice && splice.commit.parent[0] !== lastSplice.oid) {
+ console.dir(splice, { depth: Infinity })
+ console.dir(lastSplice, { depth: Infinity })
+ throw new Error('parent mismatch: ' + splice.oid)
+ }
+ lastSplice = splice
+ if (splice.changes['.io.json']) {
+ const { patch } = splice.changes['.io.json']
+ // TODO move to unified diff patches
+ if (!patch) {
+ throw new Error('io.json patch not found')
+ }
+ const io = JSON.parse(patch)
+ this.#resolvePierces(io)
+ }
+ }
+ }
+ #resolvePierces(io: IoStruct) {
+ for (const [, value] of Object.entries(io.requests)) {
+ if (isPierceRequest(value)) {
+ if (this.#pierces.has(value.ulid)) {
+ const outcome = getOutcomeFor(io, value.ulid)
+ if (outcome) {
+ const promise = this.#pierces.get(value.ulid)
+ this.#pierces.delete(value.ulid)
+ if (!promise) {
+ throw new Error('Promise not found')
+ }
+ if (outcome.error) {
+ promise.reject(deserializeError(outcome.error))
+ } else {
+ promise.resolve(outcome.result)
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+const getOutcomeFor = (io: IoStruct, ulid: string) => {
+ for (const [key, value] of Object.entries(io.requests)) {
+ if (isPierceRequest(value)) {
+ if (value.ulid === ulid) {
+ const sequence = parseInt(key)
+ return io.replies[sequence]
+ }
+ }
+ }
+}
diff --git a/_import-artifact/api/zod.ts b/_import-artifact/api/zod.ts
new file mode 100644
index 000000000000..b26b81347e60
--- /dev/null
+++ b/_import-artifact/api/zod.ts
@@ -0,0 +1,92 @@
+import { z } from 'zod'
+
+// Define the schema for content parts (text and image)
+const ChatCompletionContentPartTextSchema = z.object({
+ type: z.literal('text'),
+ text: z.string(),
+})
+
+const ChatCompletionContentPartImageSchema = z.object({
+ type: z.literal('image_url'),
+ image_url: z.object({
+ url: z.string(),
+ detail: z.enum(['auto', 'low', 'high']).optional(),
+ }),
+})
+
+const ChatCompletionContentPartRefusalSchema = z.object({
+ refusal: z.string(),
+ type: z.literal('refusal'),
+})
+
+const ChatCompletionContentSchema = z.union([
+ z.string(),
+ z.array(
+ z.union([
+ ChatCompletionContentPartTextSchema,
+ ChatCompletionContentPartImageSchema,
+ ]),
+ ),
+])
+
+const ChatCompletionContentResponseSchema = z.union([
+ z.string(),
+ z.array(ChatCompletionContentPartTextSchema),
+])
+
+const systemMessage = z.object({
+ content: ChatCompletionContentResponseSchema,
+ role: z.literal('system'),
+ name: z.string().optional(),
+})
+
+// Define the user message schema
+const userMessage = z.object({
+ content: ChatCompletionContentSchema,
+ role: z.literal('user'),
+ name: z.string().optional(),
+})
+
+// Define the assistant message schema
+export type AssistantMessage = z.infer<
+ typeof assistantMessage
+>
+export const assistantMessage = z.object({
+ role: z.literal('assistant'),
+ content: z.union([
+ z.string(),
+ z.array(z.union([
+ ChatCompletionContentPartTextSchema,
+ ChatCompletionContentPartRefusalSchema,
+ ])),
+ ]).optional().nullable(),
+ name: z.string().optional(),
+ refusal: z.string().optional().nullable(),
+ tool_calls: z
+ .array(
+ z.object({
+ id: z.string(),
+ type: z.literal('function'),
+ function: z.object({
+ name: z.string(),
+ arguments: z.string(),
+ }),
+ }),
+ )
+ .optional(),
+})
+
+export type ToolMessage = z.infer
+const toolMessage = z.object({
+ role: z.literal('tool'),
+ content: ChatCompletionContentResponseSchema,
+ tool_call_id: z.string(),
+})
+
+export type CompletionMessage = z.infer
+export const completionMessage = z.union([
+ systemMessage,
+ userMessage,
+ assistantMessage,
+ toolMessage,
+])
diff --git a/_import-artifact/atomic.ts b/_import-artifact/atomic.ts
new file mode 100644
index 000000000000..9b5ecc8df3e3
--- /dev/null
+++ b/_import-artifact/atomic.ts
@@ -0,0 +1,175 @@
+import * as keys from './keys.ts'
+import { hasPoolables } from '@/db.ts'
+import {
+ isMergeReply,
+ PID,
+ Poolable,
+ PooledRef,
+ QueueMessage,
+ QueueMessageType,
+ sha1,
+} from '@/constants.ts'
+import { assert, Debug, isKvTestMode } from '@utils'
+
+const log = Debug('AI:db:atomic')
+
+export class Atomic {
+ // TODO handle max pool size creating too large an atomic transaction
+ #kv: Deno.Kv
+ #atomic: Deno.AtomicOperation | undefined
+ #transmitted = new Map()
+ private constructor(kv: Deno.Kv) {
+ this.#kv = kv
+ this.#atomic = kv.atomic()
+ }
+ static create(kv: Deno.Kv) {
+ return new Atomic(kv)
+ }
+ /**
+ * Used in two scenarios:
+ * 1. When a pierce occurs, and adding to the pool is at the point of ulid
+ * generation, guaranteeing atomicity by way of the ulid
+ * 2. During the atomic transmission process, where it is guaranteed to only
+ * be added if the commit to head is successful
+ * @param poolable
+ * @returns
+ */
+ addToPool(poolable: Poolable) {
+ assert(this.#atomic, 'Atomic not set')
+ log('pooling start %o', poolable)
+ const key = keys.getPoolKey(poolable)
+ const empty = { key, versionstamp: null }
+ const { commit, sequence, source } = poolable
+ const isReply = isMergeReply(poolable)
+
+ const ref: PooledRef = { commit, sequence, source, isReply }
+ this.#atomic = this.#atomic.check(empty).set(key, ref)
+
+ const poolKey = JSON.stringify(keys.getPoolKeyPrefix(poolable.target))
+ if (!this.#transmitted.has(poolKey)) {
+ this.#transmitted.set(poolKey, { pid: poolable.target, count: BigInt(0) })
+ }
+ const buffer = this.#transmitted.get(poolKey)
+ assert(buffer)
+ buffer.count++
+ return this
+ }
+ deletePool(pid: PID, poolKeys: Deno.KvKey[]) {
+ assert(this.#atomic, 'Atomic not set')
+ log('deletePool %o', poolKeys.map((key) => key[key.length - 1]))
+ for (const key of poolKeys) {
+ this.#atomic = this.#atomic.delete(key)
+ }
+ const markerKey = keys.getPoolMarkerKey(pid)
+ this.#atomic = this.#atomic.sum(markerKey, BigInt(poolKeys.length))
+ return this
+ }
+ async updateHead(pid: PID, fromCommit: string, toCommit: string) {
+ assert(this.#atomic, 'Atomic not set')
+ assert(sha1.test(fromCommit), 'Commit not SHA-1: ' + fromCommit)
+ assert(sha1.test(toCommit), 'Commit not SHA-1: ' + toCommit)
+ assert(fromCommit !== toCommit, 'Commits are the same')
+ const key = keys.getHeadKey(pid)
+ log('updateHead %o', key, fromCommit, toCommit)
+ const from = await this.#kv.get(key)
+ if (from.value !== fromCommit) {
+ return false
+ }
+ this.#atomic = this.#atomic.check(from).set(key, toCommit)
+ return this
+ }
+ createBranch(pid: PID, commit: string) {
+ // TODO check the pid is based on this pid
+ assert(this.#atomic, 'Atomic not set')
+ assert(sha1.test(commit), 'Commit not SHA-1: ' + commit)
+ const key = keys.getHeadKey(pid)
+ this.#atomic = this.#atomic.check({ key, versionstamp: null })
+ .set(key, commit)
+ return this
+ }
+ /**
+ * @param pid the branch to delete
+ * @param commit the current branch commit that is being deleted, which is
+ * used to provide safety in case something else has changed the branch
+ */
+ async deleteBranch(pid: PID, commit: string) {
+ assert(this.#atomic, 'Atomic not set')
+ assert(sha1.test(commit), 'Commit not SHA-1: ' + commit)
+ const key = keys.getHeadKey(pid)
+ const current = await this.#kv.get(key)
+ if (!current.versionstamp || current.value !== commit) {
+ return false
+ }
+ this.#atomic = this.#atomic.check(current).delete(key)
+ return this
+ // TODO ensure this is tied in to the changing of the parent head
+ }
+ /** Queue up a serial request for execution
+ * @param commit the commit to provide to the execution environment when the
+ * request is run
+ */
+ enqueueExecution(pid: PID, sequence: number, commit: string) {
+ const type = QueueMessageType.EXECUTION
+ return this.#enqueue({ type, pid, sequence, commit })
+ }
+ enqueueBranch(parentCommit: string, parentPid: PID, sequence: number) {
+ const type = QueueMessageType.BRANCH
+ return this.#enqueue({ type, parentCommit, parentPid, sequence })
+ }
+ #enqueuePool(pid: PID) {
+ const type = QueueMessageType.POOL
+ return this.#enqueue({ type, pid })
+ }
+ #enqueue(message: QueueMessage) {
+ assert(this.#atomic, 'Atomic not set')
+ const backoffSchedule = isKvTestMode() ? [] : undefined
+ this.#atomic = this.#atomic.enqueue(message, {
+ keysIfUndelivered: [keys.UNDELIVERED],
+ backoffSchedule,
+ })
+ return this
+ }
+ #increasePool(pid: PID, amount: bigint) {
+ assert(this.#atomic, 'Atomic not set')
+ const counterKey = keys.getPoolCounterKey(pid)
+ this.#atomic = this.#atomic.sum(counterKey, amount)
+ return this
+ }
+ #checkMarker(marker: Deno.KvEntryMaybe) {
+ assert(this.#atomic, 'Atomic not set')
+ this.#atomic = this.#atomic.check(marker)
+ return this
+ }
+ async commit() {
+ // TODO go thru all atomic usage and ensure all async ops are at the end
+ assert(this.#atomic, 'Atomic not set')
+
+ const markerCounterKeys = []
+ const transmissions = [...this.#transmitted.values()]
+ for (const { pid, count } of transmissions) {
+ markerCounterKeys.push(keys.getPoolMarkerKey(pid))
+ const counterKey = keys.getPoolCounterKey(pid)
+ markerCounterKeys.push(counterKey)
+ this.#increasePool(pid, count)
+ }
+ const markerCounters = await this.#kv.getMany(markerCounterKeys)
+ for (let i = 0; i < markerCounters.length; i += 2) {
+ const marker = markerCounters[i]
+ const counter = markerCounters[i + 1]
+
+ this.#checkMarker(marker)
+ const mayBeEmpty = true
+ if (!hasPoolables(counter, marker, mayBeEmpty)) {
+ // if one was processed, all were processed ☢️
+ this.#enqueuePool(transmissions[i].pid)
+ }
+ }
+ const atomic = this.#atomic
+ this.#atomic = undefined
+ const result = await atomic.commit()
+ if (!result.ok) {
+ return false
+ }
+ return true
+ }
+}
diff --git a/_import-artifact/benchmarks/bench.ts b/_import-artifact/benchmarks/bench.ts
new file mode 100644
index 000000000000..e4aecc9af195
--- /dev/null
+++ b/_import-artifact/benchmarks/bench.ts
@@ -0,0 +1,206 @@
+import Benchmark from 'benchmark'
+import { Debug } from '@utils'
+import { Engine } from '@/engine.ts'
+import { Api } from '@/isolates/io-fixture.ts'
+import { assert } from '@std/assert'
+import DB from '@/db.ts'
+import { Crypto } from '../api/crypto.ts'
+import { Backchat } from '../api/client-backchat.ts'
+
+const log = Debug('AI:benchmarks')
+Debug.enable('AI:benchmarks AI:qbr')
+log('starting benchmarks')
+
+const suite = new Benchmark.Suite()
+
+const superuserKey =
+ 'ed7a15e43c8ca247b61b61af438392b31b71fe2e9eb500b58e0773fc5eb99b8b'
+const aesKey = DB.generateAesKey()
+
+const engines: Engine[] = []
+const factory = async () => {
+ const engine = await engineFactory()
+ const privateKey = Crypto.generatePrivateKey()
+ const backchat = await Backchat.upsert(engine, privateKey)
+ return backchat
+}
+const engineFactory = async () => {
+ const engine = await Engine.provision(superuserKey, aesKey)
+ engines.push(engine)
+ return engine
+}
+const machineEngine = await engineFactory()
+const machineEnginePrivateKey = Crypto.generatePrivateKey()
+Crypto.load(machineEnginePrivateKey) // do premul crypto so run is not skewed
+
+const backchatStartThread = await factory()
+const backchatReload = await factory()
+
+const hotPing = await factory()
+const hotPingActions = await hotPing.actions('io-fixture')
+const install = await factory()
+let installCounter = 0
+
+log('setup complete')
+
+suite
+ // ENGINE
+ .add('engine cold start', {
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ const engine = await Engine.provision(superuserKey, aesKey)
+ deferred.resolve()
+ await engine.stop()
+ },
+ })
+ // MACHINE
+ .add('machine root session', { // RENAME to: backchat create
+ // generate a new machine key and await backchat to upsert
+ defer: true,
+ async fn(deferred: Benchmark.Deferred) {
+ const privateKey = Crypto.generatePrivateKey()
+ await Backchat.upsert(machineEngine, privateKey)
+ deferred.resolve()
+ },
+ })
+ .add('machine reload', { // RENAME to: backchat reload
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ await Backchat.upsert(machineEngine, machineEnginePrivateKey)
+ deferred.resolve()
+ },
+ })
+ // SESSION
+ .add('boot', { // RENAME to: full boot from cold
+ // start an engine and await backchat to upsert
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ await factory()
+ deferred.resolve()
+ },
+ })
+ .add('session start', { // RENAME to: new thread
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ await backchatStartThread.newThread()
+ deferred.resolve()
+ },
+ })
+ .add('session reload', { // RENAME to: backchat reload
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ await Backchat.upsert(
+ machineEngine,
+ machineEnginePrivateKey,
+ backchatReload.id,
+ )
+ deferred.resolve()
+ },
+ })
+ // given an engine that is provisioned, how long to recover the super user ?
+
+ // multihop ping
+ // write one file then return
+ // write a deeply nested file then return
+
+ // read a shallow file
+ // read a deeply nested file externally
+ // time delay to a splice
+
+ // make a single new daemon branch
+ // make several new daemon branches
+
+ // run a benchmark from inside an isolate, skipping pierce
+ // ? how can we map how long a branch takes to make ?
+
+ .add('cold ping', { // RENAME to: create backchat then ping
+ // make a new session
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ const backchat = await Backchat.upsert(
+ machineEngine,
+ machineEnginePrivateKey,
+ )
+ const fixture = await backchat.actions('io-fixture')
+ const result = await fixture.local({})
+ assert(result === 'local reply')
+ deferred.resolve()
+ },
+ })
+ .add('hot ping', { // RENAME to: ping local
+ // use an existing session
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ const result = await hotPingActions.local({})
+ assert(result === 'local reply')
+ deferred.resolve()
+ },
+ })
+ // try get max thruput by not waiting for things to complete ?
+ // .add('publish', {
+ // make a new repo ?
+ // defer: true,
+ // fn: async (deferred) => {
+ // await publish()
+ // deferred.resolve()
+ // },
+ // })
+ .add('install', { // RENAME to: init repo
+ // time how long to install a new multi user app
+ defer: true,
+ fn: async (deferred: Benchmark.Deferred) => {
+ const repo = 'install/' + installCounter++
+ await install.init({ repo })
+ deferred.resolve()
+ },
+ })
+ // .add('add customer', {
+ // ignoring the NL operations, this is adding raw data
+ // defer: true,
+ // fn: async (deferred) => {
+ // await addCustomer()
+ // deferred.resolve()
+ // },
+ // })
+ // .add('block making', {
+ // make a new commit ?
+ // defer: true,
+ // fn: async (deferred) => {
+ // await makePulse()
+ // deferred.resolve()
+ // },
+ // })
+ // .add('unsigned block making', {
+ // make a new commit without signing it
+ // defer: true,
+ // fn: async (deferred) => {
+ // await makeUnsigned()
+ // deferred.resolve()
+ // },
+ // })
+ .on('cycle', (event: Benchmark.Event) => {
+ console.log(String(event.target))
+ })
+ .on('complete', async function () {
+ log('cleaning up')
+ let count = 0
+ for (const engine of engines) {
+ log('stopping engine', ++count)
+ await engine.stop()
+ }
+ })
+ .run({ async: false })
+
+// then do a cloud version running on a sacrificial deployment
+// hundred pings outside
+// hundred pings inside
+// time to restart an existing session
+
+// ? can a GUTS framework be made to run benchmarks in different environments
+
+// bulk copy files speed test, as well as single binary file test
+// bulk file read without cache.
+
+// multiple stage ping test
+// branch and some multiple requests test
+// also test the branch task going sequentially
diff --git a/_import-artifact/constants.ts b/_import-artifact/constants.ts
new file mode 100644
index 000000000000..4662f775b509
--- /dev/null
+++ b/_import-artifact/constants.ts
@@ -0,0 +1,251 @@
+import IA from './isolate-api.ts'
+export type { IA }
+export const IO_PATH = '.io.json'
+import {
+ type Backchat,
+ Change,
+ CommitObject,
+ EngineInterface,
+ IsolateReturn,
+ MetaPromise,
+ Outcome,
+ Params,
+ PID,
+ Pierce,
+ RemoteRequest,
+ Request,
+ SolidRequest,
+ UnsequencedRequest,
+} from './api/types.ts'
+import FS from '@/git/fs.ts'
+import type DB from '@/db.ts'
+import type Executor from '@/exe/exe.ts'
+import { assert, equal } from '@utils'
+import { JsonSchema7ObjectType, zodToJsonSchema } from 'zod-to-json-schema'
+import { ZodObject, ZodSchema, ZodUnknown } from 'zod'
+
+export const REPO_LOCK_TIMEOUT_MS = 5000
+
+/** Artifact Context, including the db and executor */
+export type C = {
+ db: DB
+ exe: Executor
+ aesKey?: string
+ seed?: Deno.KvEntry[]
+}
+
+/** Extends the actions api to be the isolate api */
+export type Functions = {
+ [K in keyof Api]: Function
+}
+
+type Function = T extends (...args: infer Args) => infer R
+ ? (...args: [...Args, IA]) => R
+ : never
+
+export type IsolateFunction = {
+ (): unknown | Promise
+ (...args: [Params]): unknown | Promise
+ (...args: [Params, IA]): unknown | Promise
+}
+
+export type IsolateFunctions = {
+ [key: string]: IsolateFunction
+}
+export type IsolateLifecycle = {
+ '@@mount'?: (api: IA) => Promise | IsolateReturn
+ '@@unmount'?: (api: IA) => Promise | IsolateReturn
+}
+export type Isolate = {
+ parameters: Record>>
+ returns: Record
+ functions: IsolateFunctions
+ lifecycles?: IsolateLifecycle
+}
+
+export type Poolable = MergeReply | RemoteRequest
+export type Reply = SolidReply | MergeReply
+export type EffectRequest = {
+ target: PID
+ /**
+ * The hash of the function that was called, to ensure repeatability
+ */
+ fingerprint: string
+ sequence: number
+}
+export type SolidReply = {
+ target: PID
+ sequence: number
+ outcome: Outcome
+}
+export type MergeReply = SolidReply & {
+ /**
+ * Where did this merge reply come from?
+ */
+ source: PID
+ /**
+ * The commit that solidified this merge reply, which is used as a merge
+ * parent in the recipient branch, so that any changes to the fs can be
+ * accessed and so the provenance of the action is included.
+ */
+ commit: string
+}
+export type IsolatePromise =
+ | BareIsolatePromise
+ | PromisedIsolatePromise
+ | SettledIsolatePromise
+type BareIsolatePromise = {
+ request: UnsequencedRequest
+}
+export type PromisedIsolatePromise = BareIsolatePromise & {
+ promise: MetaPromise
+ resolve: (value: T) => void
+ reject: (error: Error) => void
+}
+export type SettledIsolatePromise =
+ & (BareIsolatePromise | PromisedIsolatePromise)
+ & {
+ outcome: Outcome
+ /** if an outcome is given, there must be a commit associated with it, so
+ * that the execution filesystem can be ticked forwards */
+ commit: string
+ /** If the outcome was the result of a branch returning, then the parent
+ * commit of that branch is given here */
+ parent?: string
+ }
+export const isSettledIsolatePromise = (
+ p: IsolatePromise,
+): p is SettledIsolatePromise => {
+ return 'outcome' in p
+}
+export type Solids = {
+ oid: string
+ commit: CommitObject
+ /** Changed files in this commit. Empty change signals deletion. */
+ changes: { [key: string]: Change }
+ exe?: { request: SolidRequest; sequence: number }
+ branches: number[]
+ poolables: (MergeReply | RemoteRequest)[]
+ deletes: { pid: PID; commit: string }[]
+}
+export type Branched = {
+ /** The first request in the new branch */
+ origin: SolidRequest
+ /** The branch PID that needs to be created in /.git/refs */
+ pid: PID
+ /** The head of the new branch that needs to be created in /.git/refs */
+ head: string
+}
+export type ExeResult = ExeSettled | ExePending
+type ExeResultBase = {
+ /**
+ * The last filesystem that was modified during the execution run. The FS
+ * might have been bumped forwards if accumulations occurred.
+ */
+ fs: FS
+ /** If this is a side effect request, this is the lock held by for it */
+ effectsLock?: Deno.KvEntry
+}
+type ExeSettled = ExeResultBase & {
+ reply: SolidReply
+}
+type ExePending = ExeResultBase & {
+ pending: Pending
+}
+export type Pending = {
+ /** The commit that caused the requests to be generated */
+ commit: string
+ /** The requests that were generated by the latest round of execution */
+ requests: UnsequencedRequest[]
+ /** The sequence number to accumulate the pending requests against */
+ sequence: number
+}
+
+export const isMergeReply = (
+ poolable: Poolable | SolidReply,
+): poolable is MergeReply => {
+ return 'commit' in poolable && 'outcome' in poolable
+}
+export const isReply = (
+ poolable: Poolable | Pierce | SolidReply,
+): poolable is Reply => {
+ return 'outcome' in poolable
+}
+export const isRemoteRequest = (
+ poolable: Request,
+): poolable is RemoteRequest => {
+ return 'commit' in poolable && 'proctype' in poolable
+}
+/**
+ * Messages that go on the queue are one of three types. Each one is an
+ * operation that will result in a new commit, atomically. Each operation is
+ * able to detect when it is a duplicate task due to duplicate message delivery.
+ * Each task will continue to retry until it is successful, as long as its check
+ * for duplication reassures it to keep trying.
+ */
+export type QueueMessage = QueuePool | QueueExe | QueueBranch
+export enum QueueMessageType {
+ POOL = 'pool',
+ EXECUTION = 'exe',
+ BRANCH = 'branch',
+}
+export type QueuePool = {
+ type: QueueMessageType.POOL
+ pid: PID
+}
+export type QueueExe = {
+ type: QueueMessageType.EXECUTION
+ pid: PID
+ commit: string
+ sequence: number
+}
+export type QueueBranch = {
+ type: QueueMessageType.BRANCH
+ parentCommit: string
+ parentPid: PID
+ sequence: number
+}
+export const isQueuePool = (m: QueueMessage): m is QueuePool => {
+ return m.type === QueueMessageType.POOL
+}
+export const isQueueExe = (m: QueueMessage): m is QueueExe => {
+ return m.type === QueueMessageType.EXECUTION
+}
+export const isQueueBranch = (m: QueueMessage): m is QueueBranch => {
+ return m.type === QueueMessageType.BRANCH
+}
+export const isChildOf = (child: PID, parent: PID) => {
+ const childParent = { ...child, branches: child.branches.slice(0, -1) }
+ return equal(childParent, parent)
+}
+export const isBaseRepo = (pid: PID) => pid.branches.length === 1
+
+export type Provisioner = (superBackchat: Backchat) => Promise
+
+export type CradleMaker = (
+ t: Deno.TestContext,
+ /** The file url that the snapshots are associated with */
+ snapshotsFor: string,
+ updateSnapshots?: 'updateSnapshots',
+ init?: Provisioner,
+) => Promise<
+ {
+ backchat: Backchat
+ engine: EngineInterface
+ privateKey: string
+ [Symbol.asyncDispose](): Promise
+ }
+>
+
+export const toApi = (parameters: Record) => {
+ const api: Record = {}
+ for (const key of Object.keys(parameters)) {
+ const schema = zodToJsonSchema(parameters[key])
+ delete schema.$schema
+ assert('properties' in schema, 'schema must have properties')
+ api[key] = schema
+ }
+ return api
+}
+
+export * from './api/types.ts'
diff --git a/_import-artifact/cradle-maker.ts b/_import-artifact/cradle-maker.ts
new file mode 100644
index 000000000000..85f05ad6f5e6
--- /dev/null
+++ b/_import-artifact/cradle-maker.ts
@@ -0,0 +1,60 @@
+import { Engine } from './engine.ts'
+import { Crypto } from './api/crypto.ts'
+import DB from '@/db.ts'
+import { type CradleMaker, Provisioner } from '@/constants.ts'
+import { Backchat } from './api/client-backchat.ts'
+import { mockCreator } from '@/isolates/utils/mocker.ts'
+import z from 'zod'
+import { peekRandomnessCount, randomness } from '@/api/randomness.ts'
+
+const superuserKey = Crypto.generatePrivateKey()
+const aesKey = DB.generateAesKey()
+const privateKey = Crypto.generatePrivateKey()
+
+type SeedSet = {
+ count: number
+ seed: Deno.KvEntry[]
+ backchatId: string
+}
+const seeds = new Map()
+
+export const cradleMaker: CradleMaker = async (t, url, update, init) => {
+ const mock = mockCreator(z.unknown())
+ t.origin = url
+ mock.useRecorder(t, update)
+
+ const seedSet = seeds.get(init)
+ const seed = seedSet?.seed
+ const backchatId = seedSet?.backchatId
+
+ const engine = await Engine.provision(superuserKey, aesKey, init, seed)
+ const backchat = await Backchat.upsert(engine, privateKey, backchatId)
+
+ if (!seedSet) {
+ seeds.set(init, {
+ count: peekRandomnessCount(),
+ seed: await engine.dump(),
+ backchatId: backchat.id,
+ })
+ } else {
+ while (peekRandomnessCount() < seedSet.count) {
+ // must update the randomness seed if the db seed is injected
+ randomness()
+ }
+ }
+
+ const original = engine.stop.bind(engine)
+ engine.stop = async () => {
+ if (t) {
+ mock.teardown()
+ }
+ await original()
+ }
+
+ return {
+ backchat,
+ engine,
+ privateKey,
+ [Symbol.asyncDispose]: () => engine.stop(),
+ }
+}
diff --git a/_import-artifact/db.test.ts b/_import-artifact/db.test.ts
new file mode 100644
index 000000000000..96693a951138
--- /dev/null
+++ b/_import-artifact/db.test.ts
@@ -0,0 +1,8 @@
+import { expect, isKvTestMode } from '@utils'
+import DB from '@/db.ts'
+
+Deno.test('db', async () => {
+ const db = await DB.create(DB.generateAesKey())
+ expect(isKvTestMode()).toBeTruthy()
+ db.stop()
+})
diff --git a/_import-artifact/db.ts b/_import-artifact/db.ts
new file mode 100644
index 000000000000..c7bfdebf3640
--- /dev/null
+++ b/_import-artifact/db.ts
@@ -0,0 +1,509 @@
+import { pushable } from 'it-pushable'
+import { BLOB_META_KEY } from '@kitsonk/kv-toolbox/blob'
+import { CryptoKv, generateKey } from '@kitsonk/kv-toolbox/crypto'
+import * as keys from '@/keys.ts'
+import {
+ freezePid,
+ MergeReply,
+ PID,
+ Poolable,
+ PooledRef,
+ pooledRef,
+ print,
+ RemoteRequest,
+ REPO_LOCK_TIMEOUT_MS,
+ sha1,
+ Splice,
+} from '@/constants.ts'
+import { assert, Debug, equal, openKv, posix } from '@utils'
+import { Atomic } from './atomic.ts'
+import { QueueMessage } from '@/constants.ts'
+import { decodeTime, ulid } from 'ulid'
+import FS from '@/git/fs.ts'
+import IOChannel from '@io/io-channel.ts'
+
+const log = Debug('AI:db')
+export default class DB {
+ #kvStore: Deno.Kv
+ #cryptoKv: CryptoKv
+ #abort = new AbortController()
+ #aborts = new Set()
+
+ private constructor(kv: Deno.Kv, aesKey: string) {
+ this.#kvStore = kv
+ this.#cryptoKv = new CryptoKv(kv, aesKey)
+ }
+ static async create(aesKey: string, seed?: Deno.KvEntry[]) {
+ const kv = await openKv()
+ watchUndelivered(kv)
+ const db = new DB(kv, aesKey)
+ if (seed) {
+ await db.load(seed)
+ }
+ return db
+ }
+ static generateAesKey() {
+ return generateKey()
+ }
+ get #kv() {
+ if (this.#abort.signal.aborted) {
+ throw new Error('DB is closed')
+ }
+ return this.#kvStore
+ }
+ stop() {
+ if (this.#abort.signal.aborted) {
+ return
+ }
+ const kv = this.#kv
+ this.#abort.abort()
+ for (const abort of this.#aborts) {
+ abort.abort()
+ }
+ return kv.close()
+ }
+ async hasPoolables(target: PID) {
+ const counterKey = keys.getPoolCounterKey(target)
+ const markerKey = keys.getPoolMarkerKey(target)
+ const many = [counterKey, markerKey]
+ const [counter, marker] = await this.#kv.getMany(many)
+ return hasPoolables(counter, marker)
+ }
+ async getPooledActions(target: PID) {
+ // TODO should pooled actions be an FS level action ?
+ const prefix = keys.getPoolKeyPrefix(target)
+ log('getPooledActions %o', prefix)
+ const entries = this.#kv.list({ prefix }, { batchSize: 1000 })
+ const poolKeys = []
+ const pool: Poolable[] = []
+ for await (const entry of entries) {
+ // TODO test if range would not get deeply nested items
+ if (entry.key.length !== prefix.length + 1) {
+ continue
+ }
+ const id = entry.key[entry.key.length - 1]
+ if (id === keys.POOL_COUNTER || id === keys.POOL_MARKER) {
+ continue
+ }
+ poolKeys.push(entry.key)
+ const ref = pooledRef.parse(entry.value)
+ const poolable = await this.readPoolable(target, ref)
+ assert(poolable, 'Invalid poolable: ' + entry.key)
+ pool.push(poolable)
+ }
+ log('getPooledActions done %o', poolKeys.length)
+ return { poolKeys, pool }
+ }
+ async readHead(pid: PID): Promise {
+ const key = keys.getHeadKey(pid)
+ log('getHead %o', key)
+ const head = await this.#kv.get(key)
+ if (head.versionstamp) {
+ assert(sha1.test(head.value), 'Invalid head: ' + head.value)
+ return head.value
+ }
+ }
+ async lockRepo(pid: PID) {
+ const key = keys.getRepoLockKey(pid)
+ let lockId
+ do {
+ lockId = ulid()
+ const result = await this.#kv.atomic().check({ key, versionstamp: null })
+ .set(key, lockId).commit()
+ if (result.ok) {
+ // TODO use keepalives to keep re-upping the key
+ break
+ }
+
+ for await (const [lock] of this.#kv.watch<[string]>([key])) {
+ if (!lock.versionstamp) {
+ break
+ }
+ // TODO await the sooner of a new value or a timeout
+ const time = decodeTime(lock.value)
+ const remainingMs = REPO_LOCK_TIMEOUT_MS - (Date.now() - time)
+ if (remainingMs <= 0) {
+ const { ok } = await this.#kv.atomic().check(lock).delete(key)
+ .commit()
+ if (ok) {
+ console.error('OVERWROTE STALE REPO LOCK: ' + print(pid))
+ break
+ }
+ }
+ }
+ } while (!this.#abort.signal.aborted)
+ return lockId
+ }
+ async releaseRepoLock(pid: PID, lockId: string) {
+ const key = keys.getRepoLockKey(pid)
+ const current = await this.#kv.get(key)
+ if (current.value === lockId) {
+ const { ok } = await this.#kv.atomic().check(current).delete(key).commit()
+ // TODO loop until confirmed as could error for non check reasons
+ return ok
+ }
+ return false
+ }
+ async rm(pid: PID) {
+ // TODO lock the repo and delete the lock last
+ const prefix = keys.getRepoBase(pid)
+ log('rm %o', prefix)
+ const all = this.#kv.list({ prefix })
+ const deletes = []
+ for await (const { key } of all) {
+ log('deleted: ', key)
+ deletes.push(this.#kv.delete(key))
+ }
+ await Promise.all(deletes)
+ return !!deletes.length
+ }
+ async blobExists(key: Deno.KvKey) {
+ const meta = await this.#cryptoKv.getBlobMeta(key)
+ return !!meta.versionstamp
+ }
+ async blobGet(key: Deno.KvKey) {
+ const result = await this.#cryptoKv.getBlob(key)
+ return result
+ }
+ async blobSet(key: Deno.KvKey, value: ArrayBufferLike) {
+ await this.#cryptoKv.setBlob(key, value)
+ }
+ async listImmediateChildren(prefix: Deno.KvKey) {
+ const results = []
+ for await (const item of this.#kv.list({ prefix })) {
+ const end = item.key.slice(prefix.length)
+ if (end.length === 1) {
+ results.push(end[0])
+ }
+ if (end.length === 2) {
+ // TODO see what happens if the keys are named to clash with this
+ if (end[1] === BLOB_META_KEY) {
+ results.push(end[0])
+ }
+ }
+ }
+ return results
+ }
+ listen(handler: (message: QueueMessage) => Promise) {
+ this.#kv.listenQueue(handler)
+ }
+ atomic() {
+ return Atomic.create(this.#kv)
+ }
+
+ /**
+ * @param pid The branch to watch the effects lock for
+ * @param abort Trigger this abort if the lock is lost
+ * @returns
+ */
+ async watchSideEffectsLock(pid: PID, abort: AbortController) {
+ // rudely snatch the lock
+ // TODO ensure that releasing the lock is part of atomics
+ const key = keys.getEffectsLockKey(pid)
+ const lockId = ulid()
+ const { versionstamp, ok } = await this.#kv.set(key, lockId)
+ assert(ok, 'Failed to set lock')
+ const stream = this.#kv.watch([key])
+ const reader = stream.getReader()
+ abort.signal?.addEventListener('abort', () => {
+ reader.cancel()
+ })
+ const read = async () => {
+ while (stream.locked) {
+ const { value, done } = await reader.read()
+ if (done) {
+ // should this be abort ?
+ return
+ }
+ const lock = value[0]
+ if (!lock.versionstamp) {
+ continue
+ }
+ if (lock.versionstamp === versionstamp) {
+ continue
+ }
+ abort.abort()
+ }
+ }
+ read()
+ return { key, value: lockId, versionstamp }
+ }
+ /**
+ * Will return an async iterable of Splices which are in order and do not skip
+ * any intermediaries. The parent Splice will always immediately precede the
+ * child Splice.
+ *
+ * If after is not provided, then we use the head to start with. If after is
+ * provided, then everything up to that point will be retrieved.
+ * @param {string} pid - The branch to watch
+ * @param {string} [path] - Optional path of a file to watch
+ * @param {string} [after] - Optional commit to start from
+ * @param {AbortSignal} [signal] - Optional abort signal
+ * @returns
+ */
+ watchSplices(pid: PID, path?: string, after?: string, signal?: AbortSignal) {
+ freezePid(pid)
+ if (path) {
+ assert(!posix.isAbsolute(path), `path must be relative: ${path}`)
+ }
+ const abort = new AbortController()
+ this.#aborts.add(abort)
+ signal?.addEventListener('abort', () => {
+ abort.abort()
+ })
+ const sink = pushable({ objectMode: true })
+ const buffer = pushable>({ objectMode: true })
+ if (after) {
+ assert(sha1.test(after), 'Invalid after: ' + after)
+ buffer.push(this.getSplice(pid, after, path))
+ }
+ abort.signal.addEventListener('abort', () => {
+ this.#aborts.delete(abort)
+ sink.return()
+ buffer.return()
+ })
+
+ const watch = this.#kv.watch([keys.getHeadKey(pid)])
+ const pipe = async () => {
+ for await (const [result] of streamToIt(watch, abort.signal)) {
+ if (!result.versionstamp) {
+ continue
+ }
+ const commit = result.value
+ if (commit === after) {
+ continue
+ }
+ buffer.push(this.getSplice(pid, commit, path))
+ }
+ }
+ pipe().catch(buffer.throw)
+ const drain = async () => {
+ let last: Splice | undefined
+ for await (const promise of buffer) {
+ const splice = await promise
+ if (!last) {
+ if (after) {
+ assert(after === splice.oid, 'after mismatch')
+ } else {
+ sink.push(splice)
+ }
+ last = splice
+ continue
+ }
+
+ const splices = [splice]
+ while (splices[0].commit.parent[0] !== last.oid) {
+ // TODO once piece replies are tracked directly, this can be removed
+ // catch up should be the responsibility of the client, not the server
+ console.error('splice race', print(splice.pid), splices.length)
+ const primeParent = splices[0].commit.parent[0]
+ const next = await this.getSplice(pid, primeParent, path)
+ splices.unshift(next)
+ }
+ last = splice
+ splices.map((s) => sink.push(s))
+ }
+ }
+ drain().catch(sink.throw)
+ return sink as AsyncIterable
+ }
+ // TODO add aborts here, or have a master promise that is awaited
+ async getSplice(pid: PID, oid: string, path?: string) {
+ const fs = FS.open(pid, oid, this)
+ const commit = await fs.getCommit()
+ const timestamp = commit.committer.timestamp * 1000
+ const splice: Splice = { pid, oid, commit, timestamp, changes: {} }
+ if (path) {
+ // TODO make paths be an array
+ if (await fs.exists(path)) {
+ const oid = await fs.readOid(path)
+ const patch = await fs.read(path) // TODO check caching makes this fast
+ splice.changes[path] = { oid, patch }
+ }
+ }
+ return splice
+ }
+
+ async hasHomeAddress() {
+ const home = await this.#kv.get(keys.HOME_ADDRESS)
+ return !!home.versionstamp
+ }
+ async setHomeAddress(pid: PID) {
+ const empty = { key: keys.HOME_ADDRESS, versionstamp: null }
+ const result = await this.#kv.atomic().check(empty).set(
+ keys.HOME_ADDRESS,
+ pid,
+ ).commit()
+ if (!result.ok) {
+ throw new Error('Home address already set')
+ }
+ }
+ async awaitHomeAddress() {
+ const home = await this.#kv.get(keys.HOME_ADDRESS)
+ if (home.versionstamp) {
+ return home.value
+ }
+ const watch = this.#kv.watch([keys.HOME_ADDRESS])
+ for await (const [result] of streamToIt(watch, this.#abort.signal)) {
+ if (result.versionstamp) {
+ return result.value
+ }
+ }
+ if (!this.#abort.signal.aborted) {
+ throw new Error('Home address error')
+ }
+ }
+ async lockDbProvisioning() {
+ const lockId = ulid()
+ const key = keys.DB_LOCK
+ const result = await this.#kv.atomic().check({ key, versionstamp: null })
+ .set(key, lockId)
+ .commit()
+ if (result.ok) {
+ return lockId
+ }
+ }
+ async unlockDbProvisioning(lockId: string) {
+ const key = keys.DB_LOCK
+ const entry = await this.#kv.get(key)
+ if (entry.value !== lockId) {
+ console.error(`lock was taken from ${lockId} to ${entry.value}`)
+ return
+ }
+ const result = await this.#kv.atomic()
+ .check(entry)
+ .delete(key)
+ .commit()
+ if (!result.ok) {
+ console.error('unlockDB failed', lockId)
+ }
+ }
+ async awaitDbProvisioning() {
+ const key = keys.DB_LOCK
+ const watch = this.#kv.watch([key])
+ for await (const [entry] of streamToIt(watch, this.#abort.signal)) {
+ if (!entry.versionstamp) {
+ return
+ }
+ }
+ }
+ async drop() {
+ const all = this.#kv.list({ prefix: [] }, { batchSize: 1000 })
+ const promises = []
+ let count = 0
+ for await (const { key } of all) {
+ if (!equal(key, keys.DB_LOCK)) {
+ promises.push(this.#kv.delete(key))
+ }
+ if (promises.length % 1000 === 0) {
+ count += promises.length
+ await Promise.all(promises)
+ promises.length = 0
+ if (count > 0) {
+ console.log('db drop progress:', count)
+ }
+ }
+ }
+ await Promise.all(promises)
+ }
+ async dump() {
+ const all = this.#kv.list({ prefix: [] }, { batchSize: 1000 })
+ const entries = []
+ for await (const entry of all) {
+ entries.push(entry)
+ }
+ return entries
+ }
+ async load(entries: Deno.KvEntry[]) {
+ let atomic = this.#kv.atomic()
+ let count = 0
+ for (const entry of entries) {
+ count++
+ // mutation limit is 1000, but there is also a size limit
+ if (count % 500 === 0) {
+ await atomic.commit()
+ atomic = this.#kv.atomic()
+ }
+ atomic.set(entry.key, entry.value)
+ }
+ await atomic.commit()
+ }
+ async readPoolable(target: PID, ref: PooledRef) {
+ const { commit, sequence, source, isReply } = ref
+ const fs = FS.open(source, commit, this)
+ const io = await IOChannel.loadWithoutPurge(fs)
+ if (isReply) {
+ const requestSource = target
+ const outcome = io.getOutcomeBySource(requestSource, sequence)
+ const reply: MergeReply = { target, sequence, outcome, source, commit }
+ return reply
+ } else {
+ const request = io.getRequest(sequence)
+ const remoteRequest: RemoteRequest = {
+ ...request,
+ source,
+ commit,
+ }
+ return remoteRequest
+ }
+ }
+}
+
+const watchUndelivered = async (kv: Deno.Kv) => {
+ for await (const [undelivered] of kv.watch([keys.UNDELIVERED])) {
+ if (undelivered.versionstamp) {
+ console.error('undelivered', undelivered.key, undelivered.value)
+ const timestamp = new Date().toISOString()
+ await kv.set([...keys.UNDELIVERED, timestamp], undelivered.value)
+ await kv.delete(undelivered.key)
+ }
+ }
+}
+
+const streamToIt = (stream: ReadableStream, signal?: AbortSignal) => {
+ const reader = stream.getReader()
+ return {
+ async *[Symbol.asyncIterator]() {
+ if (signal?.aborted) {
+ reader.releaseLock()
+ return
+ }
+ signal?.addEventListener('abort', () => {
+ reader.releaseLock()
+ stream.cancel()
+ return
+ })
+
+ try {
+ while (stream.locked) {
+ const { done, value } = await reader.read()
+ if (done) {
+ break
+ }
+ yield value
+ }
+ } finally {
+ reader.releaseLock()
+ }
+ },
+ }
+}
+export const hasPoolables = (
+ counter: Deno.KvEntryMaybe,
+ marker: Deno.KvEntryMaybe,
+ mayBeEmpty = false,
+) => {
+ if (!counter.versionstamp) {
+ if (!mayBeEmpty) {
+ throw new Error('Pool does not exist: ' + counter.key.join('/'))
+ }
+ return false
+ }
+ if (!marker.versionstamp) {
+ return counter.value > 0
+ }
+ if (counter.value < marker.value) {
+ throw new Error('invalid marker: ' + marker.key.join('/'))
+ }
+ return counter.value > marker.value
+}
diff --git a/_import-artifact/deno.json b/_import-artifact/deno.json
new file mode 100644
index 000000000000..e88c998d896c
--- /dev/null
+++ b/_import-artifact/deno.json
@@ -0,0 +1,79 @@
+{
+ "name": "@dreamcatcher-ai/artifact",
+ "version": "0.0.1",
+ "lock": false,
+ "tasks": {
+ "test": "DENO_KV_PATH=:memory: deno test -A --coverage --clean --parallel",
+ "watch": "clear && DENO_KV_PATH=:memory: DEBUG_COLORS=1 deno test -A --watch",
+ "api": "DENO_KV_PATH=:memory: DEBUG_COLORS=1 deno run -A --watch --inspect-wait main.ts",
+ "check:types": "deno check **/*.ts",
+ "check": "deno fmt --check && deno lint && deno task check:types",
+ "ok": "deno task check && deno task test",
+ "cov:gen": "deno coverage coverage --lcov --exclude='.tsx' --output=cov.lcov",
+ "tc": "DEBUG_COLORS=1 deno test -A --unsafely-ignore-certificate-errors --trace-leaks ./server/cloud.ts",
+ "db:drop": "DEBUG_COLORS=1 deno run -A ./server/db-drop.ts",
+ "db:tools": "DEBUG_COLORS=1 deno run -A ./server/db-tools.ts",
+ "keygen": "DEBUG_COLORS=1 deno run ./server/keygen.ts",
+ "bw": "DENO_KV_PATH=:memory: DEBUG_COLORS=1 deno run -A --check --watch benchmarks/bench.ts",
+ "bench": "DENO_KV_PATH=:memory: DEBUG_COLORS=1 deno run -A benchmarks/bench.ts"
+ },
+ "imports": {
+ "$git": "npm:isomorphic-git",
+ "@/": "./",
+ "@deno/kv-oauth": "jsr:@deno/kv-oauth",
+ "@io/": "./io/",
+ "@kitsonk/kv-toolbox": "jsr:@kitsonk/kv-toolbox",
+ "@noble/hashes": "npm:@noble/hashes",
+ "@noble/secp256k1": "npm:@noble/secp256k1",
+ "@scure/base": "npm:@scure/base",
+ "@sindresorhus/is": "npm:@sindresorhus/is",
+ "@std/assert": "jsr:@std/assert",
+ "@std/async": "jsr:@std/async",
+ "@std/dotenv": "jsr:@std/dotenv",
+ "@std/expect": "jsr:@std/expect",
+ "@std/path": "jsr:@std/path@^1.0.6",
+ "@types/benchmark": "npm:@types/benchmark",
+ "@utils": "./utils.ts",
+ "benchmark": "npm:benchmark",
+ "chalk": "npm:chalk",
+ "debug": "npm:debug",
+ "diff": "npm:diff",
+ "diff3": "npm:diff3",
+ "eventsource-parser/stream": "npm:eventsource-parser/stream",
+ "fast-deep-equal/es6": "npm:fast-deep-equal/es6/index.js",
+ "gray-matter": "npm:gray-matter",
+ "hono": "jsr:@hono/hono",
+ "imagescript": "https://deno.land/x/imagescript@1.3.0/mod.ts",
+ "it-pushable": "npm:it-pushable",
+ "lodash.get": "npm:lodash.get@^4.4.2",
+ "lodash.merge": "npm:lodash.merge",
+ "lodash.set": "npm:lodash.set@^4.3.2",
+ "micromatch": "npm:micromatch",
+ "multiformats": "npm:multiformats",
+ "openai": "npm:openai",
+ "serialize-error": "npm:serialize-error",
+ "ulid": "npm:ulid",
+ "youtube-caption-extractor": "npm:youtube-caption-extractor",
+ "zod": "npm:zod",
+ "zod-to-json-schema": "npm:zod-to-json-schema"
+ },
+ "exclude": ["cov/"],
+ "lint": {
+ "rules": {
+ "tags": ["recommended"],
+ "include": ["no-boolean-literal-for-arguments"]
+ }
+ },
+ "scopes": {},
+ "fmt": {
+ "include": ["**/*.ts", "**/*.tsx"],
+ "exclude": ["coverage", "cov", "node_modules", "HAL", "tmp"],
+ "semiColons": false,
+ "singleQuote": true,
+ "proseWrap": "always",
+ "indentWidth": 2,
+ "useTabs": false
+ },
+ "unstable": ["kv"],
+ "exports": "./main.ts"
+}
diff --git a/_import-artifact/engine.test.ts b/_import-artifact/engine.test.ts
new file mode 100644
index 000000000000..9d169b61cc5e
--- /dev/null
+++ b/_import-artifact/engine.test.ts
@@ -0,0 +1,46 @@
+import { Backchat } from './api/client-backchat.ts'
+import guts from './guts/guts.ts'
+import { expect, log } from '@utils'
+import { cradleMaker } from '@/cradle-maker.ts'
+import * as backchat from './isolates/backchat.ts'
+import { getBaseName } from '@/constants.ts'
+
+Deno.test('cradle', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { engine, privateKey, backchat } = cradle
+ await t.step('basic', async () => {
+ const result = await backchat.ping({ data: 'hello' })
+ expect(result).toBe('hello')
+
+ await backchat.rm({ repo: 'dreamcatcher-tech/HAL' })
+ log('backchat', backchat.pid)
+ const clone = await backchat.clone({ repo: 'dreamcatcher-tech/HAL' })
+ log('clone result', clone)
+ expect(clone.pid).toBeDefined()
+ expect(clone.pid.account).toBe('dreamcatcher-tech')
+ expect(typeof clone.head).toBe('string')
+ })
+ let next: Backchat
+ await t.step('second backchat', async () => {
+ next = await Backchat.upsert(engine, privateKey)
+ expect(next.pid).not.toEqual(backchat.pid)
+ expect(next.id).not.toEqual(backchat.id)
+ })
+ await t.step('new thread', async () => {
+ const firstBase = await backchat.threadPID()
+ const secondBase = await next.threadPID()
+ expect(firstBase).not.toEqual(secondBase)
+
+ const { newThread } = await next.actions('backchat')
+ const threadId = await newThread({})
+ const thirdBase = await next.threadPID()
+ expect(getBaseName(thirdBase)).toEqual(threadId)
+ expect(secondBase).not.toEqual(thirdBase)
+ })
+
+ // test intercepting backchat text
+})
+
+guts(cradleMaker)
+
+// TODO confirm cannot delete the system chain
diff --git a/_import-artifact/engine.ts b/_import-artifact/engine.ts
new file mode 100644
index 000000000000..6b3dc7ecc7ee
--- /dev/null
+++ b/_import-artifact/engine.ts
@@ -0,0 +1,344 @@
+import { transcribe } from './isolates/ai-completions.ts'
+import Compartment from './io/compartment.ts'
+import '@std/dotenv/load'
+import {
+ addBranches,
+ backchatIdRegex,
+ C,
+ EngineInterface,
+ freezePid,
+ generateActorId,
+ generateBackchatId,
+ HAL,
+ JsonValue,
+ PID,
+ Pierce,
+ print,
+ Proctype,
+ Provisioner,
+} from './constants.ts'
+import * as actor from './api/isolates/actor.ts'
+import IA from './isolate-api.ts'
+import { assert, Debug, posix } from '@utils'
+import FS from '@/git/fs.ts'
+import * as artifact from '@/isolates/artifact.ts'
+import { ulid } from 'ulid'
+import { Crypto } from './api/crypto.ts'
+import { PierceWatcher } from './api/watcher.ts'
+import * as actors from './isolates/actors.ts'
+import { Backchat } from './api/client-backchat.ts'
+import { tryActorId } from '@/isolates/machines.ts'
+const log = Debug('AI:engine')
+type Seed = Deno.KvEntry[]
+
+export class Engine implements EngineInterface {
+ #superuserKey: string
+ #compartment: Compartment
+ #api: IA
+ #pierce: artifact.Api['pierce']
+ #homeAddress: PID | undefined
+ #githubAddress: PID | undefined
+ #abort = new AbortController()
+
+ private constructor(
+ compartment: Compartment,
+ api: IA,
+ superuserKey: string,
+ ) {
+ this.#compartment = compartment
+ this.#api = api
+ const functions = compartment.functions(api)
+ this.#pierce = functions.pierce
+ this.#superuserKey = superuserKey
+ }
+ static async boot(superuserKey: string, aesKey: string, seed?: Seed) {
+ const compartment = await Compartment.create('artifact')
+ const api = IA.createContext()
+ api.context = { aesKey, seed }
+ await compartment.mount(api)
+ const engine = new Engine(compartment, api, superuserKey)
+ return engine
+ }
+ static async provision(
+ superuserKey: string,
+ aesKey: string,
+ init?: Provisioner,
+ seed?: Seed,
+ ) {
+ // TODO collapse this to be same as server, so never gets called
+ const engine = await Engine.boot(superuserKey, aesKey, seed)
+ await engine.ensureHomeAddress(init)
+ return engine
+ }
+ superUser(): Backchat {
+ const crypto = Crypto.load(this.#superuserKey)
+ return Backchat.superuser(this, crypto)
+ }
+ get #isDropping() {
+ const toDelete = Deno.env.get('DROP_HOME') || ''
+ const isDropping = toDelete.trim() === this.homeAddress.repoId
+ isDropping && log('isDropping', isDropping)
+ return isDropping
+ }
+ get context() {
+ return this.#api.context
+ }
+ get homeAddress() {
+ if (!this.#homeAddress) {
+ throw new Error('home not provisioned')
+ }
+ return this.#homeAddress
+ }
+ get abortSignal() {
+ return this.#abort.signal
+ }
+ get isProvisioned() {
+ return !!this.#homeAddress && !!this.#githubAddress
+ }
+ async upsertBackchat(machineId: string, resume?: string) {
+ // TODO handshake to prove the machineId is valid
+ Crypto.assert(machineId)
+ assert(!resume || backchatIdRegex.test(resume), 'invalid resume')
+ const { db } = artifact.sanitizeContext(this.#api)
+
+ const machines = addBranches(this.homeAddress, 'machines')
+ const machineFs = await FS.openHead(machines, db)
+ let actor: PID
+
+ const actorId = await tryActorId(machineId, machineFs)
+ if (actorId) {
+ actor = addBranches(this.homeAddress, actorId)
+ } else {
+ return this.#createActor(machineId)
+ }
+ if (resume) {
+ const resumedBackchat = addBranches(actor, resume)
+ if (await db.readHead(resumedBackchat)) {
+ return resumedBackchat
+ }
+ }
+ return this.#createBackchat(actor)
+ }
+ async #createActor(machineId: string) {
+ Crypto.assert(machineId)
+ const actorId = generateActorId()
+ const actor = addBranches(this.homeAddress, actorId)
+ const backchatId = generateBackchatId()
+ const backchat = addBranches(actor, backchatId)
+
+ const target = this.homeAddress
+ const su = this.superUser()
+ const actions = await su.actions('actors', { target })
+ await actions.createActor({ actorId, machineId, backchatId })
+
+ return backchat
+ }
+ async #createBackchat(target: PID) {
+ // TODO assert is actor PID
+ // TODO this should really be done by the actor
+ // so the request should include a pierce to create a new one in case the
+ // resume doesn't work, since SU takes time
+ const su = this.superUser()
+ const { backchat } = await su.actions('actor', {
+ target,
+ })
+ const backchatId = generateBackchatId()
+ const pid = await backchat({ backchatId })
+ return freezePid(pid)
+ }
+ async ensureHomeAddress(init?: Provisioner) {
+ if (this.#homeAddress) {
+ return
+ }
+
+ log('ensureHomeAddress querying db')
+ const { db } = artifact.sanitizeContext(this.#api)
+ if (await db.hasHomeAddress()) {
+ this.#homeAddress = await db.awaitHomeAddress()
+ log('homeAddress found in db', print(this.#homeAddress))
+ }
+
+ if (!this.#homeAddress || this.#isDropping) {
+ const lockId = await db.lockDbProvisioning()
+ if (lockId) {
+ log('dropping db')
+ await this.#dropDB()
+ log('db drop complete')
+
+ log('initializing homeAddress')
+ this.#homeAddress = await this.#initHome()
+ await db.setHomeAddress(this.#homeAddress)
+ log('homeAddress initialized to:', print(this.#homeAddress))
+
+ await this.#provision(init)
+ await db.unlockDbProvisioning(lockId)
+ log('unlocked db', lockId)
+ }
+ }
+ // importantly, this blocks only web requests, not queue processing
+ await db.awaitDbProvisioning()
+ this.#homeAddress = await db.awaitHomeAddress()
+ log('db unlocked - home address:', print(this.#homeAddress))
+ }
+ async stop() {
+ this.#abort.abort()
+ await this.#compartment.unmount(this.#api)
+ // attempt to let the subtle digest call clean up
+ await new Promise((resolve) => setTimeout(() => resolve()))
+ }
+ async #initHome() {
+ // queue processing cannot begin without a home repo
+ log('initHome')
+ const { db } = artifact.sanitizeContext(this.#api)
+ const repo = `${HAL.account}/${HAL.repository}`
+ const fs = await FS.clone(repo, db)
+ log('initialized home', print(fs.pid))
+ return fs.pid
+ }
+ async #provision(init?: Provisioner) {
+ const abort = new AbortController()
+
+ const watcher = PierceWatcher.create(abort.signal, this, this.homeAddress)
+ watcher.watchPierces()
+ const { machineId: superuser } = Crypto.load(this.#superuserKey)
+ const pierce: Pierce = {
+ target: this.homeAddress,
+ ulid: ulid(),
+ isolate: 'actors',
+ functionName: '@@install',
+ params: { superuser },
+ proctype: Proctype.enum.SERIAL,
+ }
+ const promise = watcher.watch(pierce.ulid)
+
+ // notably, this is the only non terminal pierce in the whole system
+ await this.pierce(pierce)
+ // TODO sign the pierce since superuser is already present
+ log('pierced', print(this.homeAddress))
+ await promise
+ abort.abort() // TODO make this a method on the watcher
+ const su = this.superUser()
+ log('superuser is', print(su.pid))
+
+ if (!init) {
+ log('no init function - returning')
+ return
+ }
+
+ log('provisioning')
+ await init(su)
+ log('provisioned')
+ }
+ ping(data?: JsonValue): Promise {
+ log('ping', data)
+ return Promise.resolve(data)
+ // TODO return some info about the deployment
+ // version, deployment location, etc
+ // if you want to ping in a chain, use an isolate
+ }
+ async apiSchema(isolate: string) {
+ const compartment = await Compartment.create(isolate)
+ return compartment.api
+ }
+ async transcribe(audio: File) {
+ assert(audio instanceof File, 'audio must be a File')
+ const text = await transcribe(audio)
+ return { text }
+ }
+ async pierce(pierce: Pierce) {
+ await this.#pierce({ pierce })
+ }
+ watch(pid: PID, path?: string, after?: string, signal?: AbortSignal) {
+ // TODO read should take a triad and should not require strict sequence
+ freezePid(pid)
+ assert(!path || !posix.isAbsolute(path), `path must be relative: ${path}`)
+
+ const db = this.#api.context.db
+ assert(db, 'db not found')
+ const abort = new AbortController()
+ signal?.addEventListener('abort', () => abort.abort())
+ this.#abort.signal.addEventListener('abort', () => abort.abort())
+ return db.watchSplices(pid, path, after, abort.signal)
+ }
+ async splice(
+ target: PID,
+ opts: { commit?: string; path?: string; count?: number } = {},
+ ) {
+ let { commit, path, count = 1 } = opts
+ log('splice', print(target), commit, path, count)
+ const db = this.#api.context.db
+ assert(db, 'db not found')
+
+ if (!commit) {
+ commit = await db.readHead(target)
+ }
+ if (!commit) {
+ throw new Error('commit not found: ' + print(target))
+ }
+ const splices = []
+ const commits = [commit]
+ while (splices.length < count) {
+ const commit = commits.shift()
+ if (!commit) {
+ break
+ }
+ const splice = await db.getSplice(target, commit, path)
+ splices.push(splice)
+ commits.push(...splice.commit.parent)
+ }
+
+ return splices
+ }
+ async read(path: string, pid: PID, commit?: string) {
+ const fs = await this.#openFs(pid, commit)
+ log('read', path, print(pid))
+ return fs.read(path)
+ }
+ async readTree(path: string, pid: PID, commit?: string) {
+ const fs = await this.#openFs(pid, commit)
+ log('readTree', path, print(pid))
+ return fs.readTree(path)
+ }
+ async readJSON(path: string, pid: PID, commit?: string) {
+ const fs = await this.#openFs(pid, commit)
+ log('readJSON', path, print(pid))
+ return fs.readJSON(path)
+ }
+ async readBinary(path: string, pid: PID, commit?: string) {
+ const fs = await this.#openFs(pid, commit)
+ log('readBinary', path, print(pid))
+ return fs.readBinary(path)
+ }
+ async #openFs(pid: PID, commit?: string) {
+ freezePid(pid)
+
+ const db = this.#api.context.db
+ assert(db, 'db not found')
+ let fs
+ if (commit) {
+ fs = FS.open(pid, commit, db)
+ } else {
+ fs = await FS.openHead(pid, db)
+ }
+ return fs
+ }
+ async exists(path: string, pid: PID): Promise {
+ // TODO convert to triad
+ freezePid(pid)
+
+ const db = this.#api.context.db
+ assert(db, 'db not found')
+ const fs = await FS.openHead(pid, db)
+ log('exists', path, print(pid))
+ return fs.exists(path)
+ }
+ async #dropDB() {
+ log('dropping homeAddress', print(this.#homeAddress))
+ const { db } = artifact.sanitizeContext(this.#api)
+ await db.drop()
+ }
+ dump() {
+ const { db } = artifact.sanitizeContext(this.#api)
+ return db.dump()
+ }
+}
diff --git a/_import-artifact/exe/accumulator.ts b/_import-artifact/exe/accumulator.ts
new file mode 100644
index 000000000000..4058f7637e63
--- /dev/null
+++ b/_import-artifact/exe/accumulator.ts
@@ -0,0 +1,155 @@
+import {
+ META_SYMBOL,
+ PID,
+ PromisedIsolatePromise,
+ SettledIsolatePromise,
+ UnsequencedRequest,
+} from '@/constants.ts'
+import { IsolatePromise } from '@/constants.ts'
+import { assert, deserializeError, equal, expect } from '@utils'
+import FS from '@/git/fs.ts'
+
+export default class Accumulator {
+ #index = 0
+ #buffer: IsolatePromise[]
+ #fs: FS
+ #highestFs: FS
+ #new: PromisedIsolatePromise[] = []
+ #isActive = false
+ #trigger: (() => void) | undefined
+ private constructor(highestFs: FS, buffer: IsolatePromise[]) {
+ this.#buffer = buffer
+ this.#highestFs = highestFs
+ this.#fs = highestFs
+ const [first] = buffer
+ if (first) {
+ assert('commit' in first, 'first accumulation must have a commit')
+ this.#fs = highestFs.tick(first.commit)
+ }
+ }
+ static create(highestFs: FS, buffer: IsolatePromise[] = []) {
+ const acc = new Accumulator(highestFs, buffer)
+ return acc
+ }
+ get accumulations() {
+ return [...this.#new]
+ }
+ get fs() {
+ return this.#fs
+ }
+ push(promised: PromisedIsolatePromise) {
+ assert(this.isActive, 'Activity is denied')
+ assert(typeof this.#trigger === 'function', 'Trigger is not set')
+ this.#trigger()
+ this.#new.push(promised)
+ this.#buffer.push(promised)
+ }
+ #tickFs() {
+ const next = this.#buffer[this.#index]
+ if (next && 'commit' in next) {
+ this.#fs = this.#fs.tick(next.commit)
+ } else if (this.fs.oid !== this.#highestFs.oid) {
+ // we are at the final layer, so use the latest fs
+ this.#fs = this.#fs.tick(this.#highestFs.oid)
+ }
+ }
+ recover(request: UnsequencedRequest) {
+ assert(this.isActive, 'Activity is denied')
+ const index = this.#index++
+ if (this.#buffer[index]) {
+ const recovered = this.#buffer[index]
+ if (!equal(recovered.request, request)) {
+ expect(recovered.request, 'Requests are not equal').toEqual(request)
+ }
+ if ('outcome' in recovered) {
+ this.#tickFs()
+ }
+ return recovered
+ }
+ }
+ isParent(parent: string) {
+ assert(this.isActive, 'Activity is denied')
+ for (const promise of this.#buffer) {
+ if ('parent' in promise) {
+ if (promise.parent === parent) {
+ return true
+ }
+ }
+ }
+ return false
+ }
+ activate(symbol: symbol) {
+ assert(!this.isActive, 'Activity is already active')
+ assert(!this.#trigger, 'Trigger is already set')
+ this.#isActive = true
+ return new Promise((resolve) => {
+ this.#trigger = () => resolve(symbol)
+ })
+ }
+ deactivate() {
+ assert(this.isActive, 'Activity is not active')
+ this.#isActive = false
+ this.#trigger = undefined
+ }
+ get isActive() {
+ return this.#isActive
+ }
+ /**
+ * Used so that an execution can be paused, then receive replies from
+ * accumulated actions, then continue without restarting the execution. Makes
+ * it easier to debug these functions, but also can be faster to execute.
+ * This is a nice to have and the operation is equally capable of starting
+ * again, if we find ourselves replaying the operation with no existing cache.
+ *
+ * As new layers of the accumulation process occur, the filesystem object
+ * referenced by the isolate-api object will tick forwards.
+ *
+ * @param from The newer accumulator that should be copied in to the old one
+ */
+ absorb(from: Accumulator) {
+ assert(!this.isActive, '"this" is already active')
+ assert(!from.isActive, '"from" is already active')
+ if (this === from) {
+ return
+ }
+ assert(this.#buffer.length <= from.#buffer.length, '"this" must be shorter')
+ this.#highestFs = from.#highestFs
+
+ let index = 0
+ for (const source of from.#buffer) {
+ const sink = this.#buffer[index++]
+ if (!sink) {
+ this.#buffer.push(source)
+ continue
+ }
+ if (!equal(source.request, sink.request)) {
+ expect(source.request).toEqual(sink.request)
+ }
+ if ('outcome' in sink) {
+ assert('outcome' in source, 'source has no outcome')
+ assert(equal(source.outcome, sink.outcome), 'outcomes are not equal')
+ assert(equal(source.commit, sink.commit), 'commits are not equal')
+ } else if ('outcome' in source) {
+ const settledSink = sink as SettledIsolatePromise
+ settledSink.outcome = source.outcome
+ settledSink.commit = source.commit
+ settledSink.parent = source.parent
+ }
+ if ('outcome' in sink && 'promise' in sink) {
+ sink.promise[META_SYMBOL] = { parent: sink.parent }
+ if (sink.outcome.error) {
+ sink.reject(deserializeError(sink.outcome.error))
+ } else {
+ sink.resolve(sink.outcome.result)
+ }
+ }
+ }
+ this.#tickFs()
+ // TODO assert the #new matched the incoming updates exactly
+ this.#new = []
+ }
+ isPidExists(pid: PID) {
+ // TODO log this action in the buffer and make it replayable
+ return this.fs.isPidExists(pid)
+ }
+}
diff --git a/_import-artifact/exe/exe.test.ts b/_import-artifact/exe/exe.test.ts
new file mode 100644
index 000000000000..6f6530e75194
--- /dev/null
+++ b/_import-artifact/exe/exe.test.ts
@@ -0,0 +1,248 @@
+import IOChannel from '../io/io-channel.ts'
+import FS from '../git/fs.ts'
+import Executor from './exe.ts'
+import {
+ C,
+ isPierceRequest,
+ PartialPID,
+ Proctype,
+ SolidRequest,
+} from '@/constants.ts'
+import { assert, expect, log } from '@utils'
+import DB from '@/db.ts'
+import { UnsequencedRequest } from '@/constants.ts'
+import { Engine } from '@/engine.ts'
+import { Api } from '@/isolates/io-fixture.ts'
+import { fixedRandomness } from '@/api/randomness.ts'
+import { cradleMaker } from '@/cradle-maker.ts'
+
+type PartialRequest = Omit
+
+const repoId = `rep_${fixedRandomness('exe-test')}`
+const partialPid: PartialPID = {
+ account: 'exe',
+ repository: 'test',
+ branches: ['main'],
+}
+const source = { ...partialPid, repoId, account: 'higher' }
+const partialRequest: PartialRequest = {
+ isolate: 'io-fixture',
+ functionName: 'local',
+ params: {},
+ proctype: Proctype.enum.SERIAL,
+ source,
+ sequence: 0,
+}
+const mocks = async (initialRequest: PartialRequest) => {
+ const db = await DB.create(DB.generateAesKey())
+ let fs = await FS.init(partialPid, db)
+ let io = await IOChannel.load(fs)
+ const request = { ...initialRequest, target: fs.pid }
+ io.addRequest(request)
+ io.setExecution()
+ io.save()
+ const { next } = await fs.writeCommitObject('mock exe')
+ fs = next
+ io = await IOChannel.load(fs)
+ const stop = () => db.stop()
+ const exe = Executor.createCacheContext()
+ const context: C = { db, exe }
+ return { request, context, exe, io, fs, db, stop }
+}
+Deno.test('simple', async (t) => {
+ const { request, context, exe, fs, stop } = await mocks(partialRequest)
+ await t.step('no accumulations', async () => {
+ const result = await exe.execute(request, fs.oid, context)
+ assert('reply' in result)
+ const { reply, fs: settledFs } = result
+ expect(reply.target).toEqual(fs.pid)
+ expect(reply.outcome).toEqual({ result: 'local reply' })
+ expect(settledFs).toEqual(fs)
+ expect(settledFs.isChanged).toBeFalsy()
+ })
+ stop()
+})
+Deno.test('writes', async (t) => {
+ const write = {
+ ...partialRequest,
+ functionName: 'write',
+ params: { path: 'test.txt', content: 'hello' },
+ }
+ const { request, context, exe, fs, stop } = await mocks(write)
+ await t.step('single file', async () => {
+ const result = await exe.execute(request, fs.oid, context)
+ assert('reply' in result)
+ const { reply, fs: settledFs } = result
+ expect(reply.target).toEqual(fs.pid)
+ expect(reply.outcome.result).toBeUndefined()
+ expect(settledFs).toEqual(fs)
+ expect(settledFs.upserts).toEqual(['test.txt'])
+ expect(settledFs.deletes).toHaveLength(0)
+ })
+ stop()
+ // write, delete, write
+ // write, delete,
+ // delete existing file
+ // multiple writes to the same file
+
+ // check the broadcasting is working
+ // throttle the broadcast updates - thrash to check it works
+})
+
+Deno.test('loopback', async () => {
+ const compound = {
+ ...partialRequest,
+ functionName: 'compound',
+ params: { target: source },
+ }
+ const { request, context, exe, fs, stop } = await mocks(compound)
+ const result = await exe.execute(request, fs.oid, context)
+ expect('pending' in result).toBeTruthy()
+ stop()
+})
+
+Deno.test('compound', async (t) => {
+ const target = {
+ repoId: `rep_${fixedRandomness('compound')}`,
+ account: 'exe',
+ repository: 'other',
+ branches: ['other'],
+ }
+ const compound = {
+ isolate: 'io-fixture',
+ proctype: Proctype.enum.SERIAL,
+ source,
+ sequence: 0,
+ functionName: 'compound',
+ params: { target },
+ }
+ const { request, context, exe, io, fs, stop } = await mocks(compound)
+ let unsequenced: UnsequencedRequest
+ await t.step('half done', async () => {
+ const result = await exe.execute(request, fs.oid, context)
+ expect(result).toHaveProperty('pending')
+ assert('pending' in result)
+ const { requests } = result.pending
+ expect(requests).toHaveLength(1)
+ unsequenced = requests[0]
+ log('internalRequest', unsequenced)
+ expect(unsequenced.target).toEqual(target)
+ })
+ await t.step('reply using function cache', async () => {
+ const sequenced = io.addPending(0, fs.oid, [unsequenced])
+ expect(sequenced).toHaveLength(1)
+ const target = sequenced[0].source
+ const reply = {
+ target,
+ source: target,
+ outcome: { result: 'compound reply' },
+ sequence: sequenced[0].sequence,
+ commit: '9e77f98333897ce63bf993280994d5e96c1679ff',
+ }
+
+ const savedRequest = io.reply(reply)
+ assert(!isPierceRequest(savedRequest))
+ expect(savedRequest).toEqual(sequenced[0])
+ io.setExecution()
+ io.save()
+ const { next } = await fs.writeCommitObject('function cache')
+
+ const result = await exe.execute(request, next.oid, context)
+ expect('reply' in result).toBeTruthy()
+ })
+ await t.step('reply from replay', async () => {
+ assert(request)
+ const io = await IOChannel.load(fs)
+ const sequenced = io.addPending(0, fs.oid, [request])
+ expect(sequenced).toHaveLength(1)
+ const target = fs.pid
+ const reply = {
+ target,
+ source: target,
+ commit: '0088107ee2fe3d8350d64b8b0098081a3db08adc',
+ outcome: { result: 'compound reply' },
+ sequence: sequenced[0].sequence,
+ }
+ io.reply(reply)
+ io.setExecution()
+ io.save()
+ const { next } = await fs.writeCommitObject('function replay')
+
+ const c = { ...context, exe: Executor.createCacheContext() }
+ const result = await c.exe.execute(request, next.oid, c)
+ expect('reply' in result).toBeTruthy()
+ })
+ stop()
+
+ // multiple outstanding requests
+ // test that it will not get rerun unless all outstanding are returned
+ // test rejection
+ // dangling requests are awaited until function resolves
+ // branch request to self is ok
+ // test multiple cycles thru requests and replies
+ // test making different request between two invocations
+})
+
+// TODO convert this to use the cradle maker
+
+const provision = async (t: Deno.TestContext, withExeCache: boolean) => {
+ const cradle = await cradleMaker(t, import.meta.url)
+ if (!withExeCache) {
+ assert(cradle.engine instanceof Engine)
+ assert(cradle.engine.context.exe, 'exe should be defined')
+ cradle.engine.context.exe.disableFunctionCache()
+ }
+ return cradle
+}
+
+for (const withExeCache of [true, false]) {
+ Deno.test(`commit spanning (cache: ${withExeCache}`, async (t) => {
+ await t.step(`function cache`, async () => {
+ await using cradle = await provision(t, withExeCache)
+ const { backchat } = cradle
+
+ const { fileAccumulation } = await backchat.actions('io-fixture')
+ await fileAccumulation({ path: 'test.txt', content: 'hello', count: 3 })
+
+ let first
+ for await (const splice of backchat.watch(backchat.pid, 'test.txt')) {
+ first = splice
+ break
+ }
+ assert(first)
+ const file = first.changes['test.txt'].patch
+ assert(file)
+ log(file)
+ expect(file.split('\n')).toHaveLength(7)
+ })
+ })
+
+ Deno.test(`looping accumulation (cache: ${withExeCache}`, async (t) => {
+ await t.step(`function cache ${withExeCache}`, async () => {
+ await using cradle = await provision(t, withExeCache)
+ const { backchat } = cradle
+
+ const { pid } = backchat
+ const { loopAccumulation } = await backchat.actions(
+ 'io-fixture',
+ { target: pid },
+ )
+ await loopAccumulation({ path: 'test.txt', content: 'hello', count: 3 })
+
+ let first
+ for await (const splice of backchat.watch(pid, 'test.txt')) {
+ first = splice
+ break
+ }
+ assert(first)
+ const file = first.changes['test.txt'].patch
+ assert(file)
+ log(file)
+ expect(file.split('\n')).toHaveLength(9)
+ })
+ })
+}
+
+// verify that pierce cannot interrupt a running in band accumulation
+// test repeat calling should not corrupt the cache, and should return the same,
+// even if the commit was several accumulations ago
diff --git a/_import-artifact/exe/exe.ts b/_import-artifact/exe/exe.ts
new file mode 100644
index 000000000000..cc10826c04ee
--- /dev/null
+++ b/_import-artifact/exe/exe.ts
@@ -0,0 +1,138 @@
+import IOChannel from '../io/io-channel.ts'
+import { getExeId } from '@/keys.ts'
+import {
+ C,
+ ExeResult,
+ JsonValue,
+ Outcome,
+ SolidReply,
+ SolidRequest,
+} from '@/constants.ts'
+import IA from '../isolate-api.ts'
+import Compartment from '../io/compartment.ts'
+import { assert, Debug, equal, serializeError } from '@utils'
+import Accumulator from '@/exe/accumulator.ts'
+import FS from '@/git/fs.ts'
+const log = Debug('AI:exe')
+
+export default class Executor {
+ #functions = new Map()
+ #functionCacheDisabled = false
+ static createCacheContext() {
+ return new Executor()
+ }
+ disableFunctionCache() {
+ this.#functionCacheDisabled = true
+ }
+ /**
+ * @param req
+ * @param commit The commit that caused this invocation, which might be the
+ * commit of the request, or the commit of the most recent accumulation that
+ * allowed this execution to continue.
+ * @param c
+ * @returns
+ */
+ async execute(req: SolidRequest, commit: string, c: C): Promise {
+ const fs = FS.open(req.target, commit, c.db)
+ assert(equal(fs.pid, req.target), 'target is not self')
+ const io = await IOChannel.read(fs)
+ assert(io, 'io not found')
+ assert(io.isExecution(req), 'request is not callable')
+ log('request %o %o', req.isolate, req.functionName, commit)
+
+ const accumulator = io.getAccumulator(fs)
+
+ // if this is a side effect, we need to get the side effect lock
+ // then this check needs to be added into everything that the api does
+ // we need to start watching for changes to the lock value
+
+ const exeId: string = getExeId(req)
+ if (this.#functionCacheDisabled || !this.#functions.has(exeId)) {
+ log('creating execution %o', exeId)
+ const opts = { isEffect: true, isEffectRecovered: false }
+ // TODO read side effect config from io.json
+ const { runnable, commit } = io.getExecution()
+ assert(runnable, 'origin not found')
+ const isolateApi = IA.create(accumulator, runnable, commit, opts)
+ if (req.isolate === 'system') {
+ log('system isolate')
+ isolateApi.context = c
+ }
+ const compartment = await Compartment.create(req.isolate)
+ const functions = compartment.functions(isolateApi)
+ const execution = {
+ function: Promise.resolve().then(() => {
+ if (!(req.functionName in functions)) {
+ const msg = `isolate: ${req.isolate} function: ${req.functionName}`
+ throw new Error('function not found: ' + msg)
+ }
+ return functions[req.functionName](req.params)
+ }).then((result) => {
+ const outcome: Outcome = {}
+ if (result !== undefined) {
+ outcome.result = result as JsonValue // sorry 🤷
+ log('self result: %o', outcome.result)
+ }
+ return outcome
+ }).catch((error) => {
+ // TODO cancel all outstanding requests
+ // and transmit them to the chains that are running them
+ log('error', error.message)
+ const outcome: Outcome = { error: serializeError(error) }
+ return outcome
+ }),
+ accumulator,
+ api: isolateApi,
+ commits: [fs.oid],
+ }
+ this.#functions.set(exeId, execution)
+ } else {
+ const execution = this.#functions.get(exeId)
+ assert(execution, 'execution not found')
+ if (execution.commits.includes(fs.oid)) {
+ // TODO exe should be idempotent ?
+ throw new Error('request already executed for commit: ' + fs.oid)
+ }
+ }
+ log('running execution %o', exeId)
+ const execution = this.#functions.get(exeId)
+ assert(execution, 'execution not found')
+
+ execution.commits.push(fs.oid)
+ execution.accumulator.absorb(accumulator)
+
+ const trigger = Symbol('🏎️')
+ const accumulatorPromise = execution.accumulator.activate(trigger)
+ const outcome = await Promise.race([execution.function, accumulatorPromise])
+ execution.accumulator.deactivate()
+
+ let result: ExeResult
+ const sequence = io.getSequence(req)
+ if (outcome === trigger) {
+ const { accumulations } = execution.accumulator
+ assert(accumulations.length > 0, 'no accumulations')
+ log('accumulator triggered first', accumulations)
+ const requests = accumulations.map((a) => a.request)
+ result = {
+ fs: execution.accumulator.fs,
+ pending: { commit: fs.oid, requests, sequence },
+ }
+ } else {
+ assert(typeof outcome === 'object')
+ log('exe complete %o', exeId)
+ this.#functions.delete(exeId)
+ const target = fs.pid
+ const reply: SolidReply = { target, sequence, outcome }
+
+ result = { fs: execution.accumulator.fs, reply }
+ }
+ return result
+ }
+}
+
+type Execution = {
+ function: Promise
+ accumulator: Accumulator
+ api: IA
+ commits: string[]
+}
diff --git a/_import-artifact/git/branch.test.ts b/_import-artifact/git/branch.test.ts
new file mode 100644
index 000000000000..996b16860bf8
--- /dev/null
+++ b/_import-artifact/git/branch.test.ts
@@ -0,0 +1,120 @@
+import { assert, expect, log, merge } from '@utils'
+import { solidify } from '@/git/solidify.ts'
+import { branch } from '@/git/branch.ts'
+import {
+ IoStruct,
+ isMergeReply,
+ MergeReply,
+ PartialPID,
+ PID,
+ Pierce,
+ Proctype,
+ UnsequencedRequest,
+} from '@/constants.ts'
+import FS from '@/git/fs.ts'
+import DB from '@/db.ts'
+
+Deno.test('pierce branch', async (t) => {
+ const partial: PartialPID = {
+ account: 'git',
+ repository: 'test',
+ branches: ['main'],
+ }
+ const db = await DB.create(DB.generateAesKey())
+ const baseFs = await FS.init(partial, db)
+ const target = baseFs.pid
+ const mockRequest: UnsequencedRequest = {
+ target,
+ isolate: 'mock',
+ functionName: 'mock',
+ params: {},
+ proctype: Proctype.enum.SERIAL,
+ }
+ const branchPierce = (ulid: string): Pierce => ({
+ target,
+ ulid,
+ isolate: 'test-isolate',
+ functionName: 'test',
+ params: { request: mockRequest },
+ proctype: Proctype.enum.BRANCH,
+ })
+ const reply: MergeReply = {
+ target,
+ sequence: 0,
+ outcome: { result: 'test-result' },
+ commit: '4b825dc642cb6eb9a060e54bf8d69288fbee4904',
+ source: target,
+ }
+ const pierce = branchPierce('pierce')
+ let head: string
+ let parentHead: string
+ let branches: number[]
+ let branchPid: PID
+
+ await t.step('parent', async () => {
+ const solids = await solidify(baseFs, [pierce])
+ head = solids.oid
+ parentHead = head
+ branches = solids.branches
+ expect(branches).toEqual([0])
+ expect(solids.exe).toBeUndefined()
+ const next = FS.open(baseFs.pid, head, db)
+ expect(next.oid).toEqual(solids.oid)
+ const io = await next.readJSON('.io.json')
+ expect(io.sequence).toBe(1)
+ expect(io.requests[0]).toEqual(pierce)
+ expect(io.requests[0].proctype).toEqual(Proctype.enum.BRANCH)
+ })
+ await t.step('child', async () => {
+ const parentFs = FS.open(baseFs.pid, head, db)
+ expect(parentFs.oid).toEqual(head)
+ expect(branches).toEqual([0])
+ const sequence = branches[0]
+ const branched = await branch(parentFs, sequence)
+ expect(branched.origin.source).toEqual(pierce.target)
+ head = branched.head
+ branchPid = branched.origin.target
+ expect(branchPid).toEqual(branched.pid)
+ })
+ let mergeReply: MergeReply
+ await t.step('child reply', async () => {
+ const branchReply = merge({}, reply, { target: branchPid })
+ const branchFs = FS.open(branchPid, head, db)
+ expect(branchFs.oid).toEqual(head)
+ const solids = await solidify(branchFs, [branchReply])
+ const { poolables } = solids
+ log('poolables', poolables[0])
+ expect(poolables.length).toBe(1)
+ assert(isMergeReply(poolables[0]))
+ mergeReply = poolables[0]
+ expect(mergeReply.outcome).toEqual(reply.outcome)
+ expect(mergeReply.target).toEqual(target)
+
+ const { commit, sequence, source } = mergeReply
+ const isReply = true
+ const recovered = await db.readPoolable(mergeReply.target, {
+ commit,
+ sequence,
+ source,
+ isReply,
+ })
+ expect(recovered).toEqual(mergeReply)
+ })
+ await t.step('child merge to parent', async () => {
+ const parentFs = FS.open(baseFs.pid, parentHead, db)
+ expect(parentFs.oid).not.toEqual(head)
+
+ const { poolables, oid } = await solidify(parentFs, [mergeReply])
+ expect(poolables).toHaveLength(0)
+ const next = FS.open(parentFs.pid, oid, db)
+ const io = await next.readJSON('.io.json')
+ const outcome = io.replies[0]
+ expect(outcome).toEqual(mergeReply.outcome)
+ const lastCommit = await next.getCommit()
+ expect(lastCommit.parent).toHaveLength(2)
+ })
+ db.stop()
+})
+// TODO delete branches
+// TODO custom names honoured
+// TODO error if name collision
diff --git a/_import-artifact/git/branch.ts b/_import-artifact/git/branch.ts
new file mode 100644
index 000000000000..4802d28a0826
--- /dev/null
+++ b/_import-artifact/git/branch.ts
@@ -0,0 +1,55 @@
+import { assert, Debug } from '@utils'
+import { Branched, Proctype } from '@/constants.ts'
+import { RemoteRequest } from '@/constants.ts'
+import IOChannel from '../io/io-channel.ts'
+import { solidify } from './solidify.ts'
+import FS from '@/git/fs.ts'
+
+const log = Debug('AI:git:branch')
+
+/**
+ * Given the fs from the parent branch, create a new branch from the
+ * given commit.
+ * @param fs the parent fs
+ * @param sequence the request sequence number in the parent to branch with
+ * @param atomic the atomic transaction object
+ */
+export const branch = async (fs: FS, sequence: number) => {
+ assert(!fs.isChanged, 'Cannot branch from a changed fs')
+ assert(sequence >= 0, 'sequence must be a whole number')
+ log('branch', sequence, fs.oid)
+ const io = await IOChannel.load(fs)
+ const pid = io.getBranchPid(sequence)
+
+ const { isolate, functionName, params, deletes } = io.getRequest(sequence)
+
+ const origin: RemoteRequest = {
+ isolate,
+ functionName,
+ params,
+ target: pid,
+ source: fs.pid,
+ sequence,
+ proctype: Proctype.enum.SERIAL,
+ commit: fs.oid,
+ }
+ log('origin', origin)
+ const branch = fs.branch(pid)
+ IOChannel.blank(branch)
+ if (deletes) {
+ deletes.forEach((d) => branch.delete(d))
+ }
+ // TODO handle branch exists with an error reply
+
+ const solids = await solidify(branch, [origin])
+ assert(solids.exe, 'must have an exe')
+ assert(solids.branches.length === 0, 'must have no branches')
+ assert(solids.poolables.length === 0, 'must have no poolables')
+ assert(solids.deletes.length === 0, 'must have no deletes')
+ const branched: Branched = {
+ origin: solids.exe.request,
+ head: solids.oid,
+ pid,
+ }
+ return branched
+}
diff --git a/_import-artifact/git/fs.test.ts b/_import-artifact/git/fs.test.ts
new file mode 100644
index 000000000000..3ecb0831d9bf
--- /dev/null
+++ b/_import-artifact/git/fs.test.ts
@@ -0,0 +1,233 @@
+import * as utils from '@utils'
+import DB from '@/db.ts'
+import FS from './fs.ts'
+import { addBranches, addPeer, IO_PATH, partialFromRepo } from '@/constants.ts'
+const { expect } = utils
+Deno.test('git/init', async (t) => {
+ const db = await DB.create(DB.generateAesKey())
+ let fs: FS
+ await t.step('init', async () => {
+ const repo = 'account/repo'
+ const pid = partialFromRepo(repo)
+ fs = await FS.init(pid, db)
+ await expect(fs.read('hello.txt')).rejects.toThrow(
+ 'Could not find hello.txt',
+ )
+ expect(await db.readHead(fs.pid)).toBe(fs.oid)
+ })
+ await t.step('git paths', async () => {
+ const git = 'git paths are forbidden: '
+ const json = 'path must be *.json'
+ const paths = [
+ '.git',
+ '.git/something',
+ '.git/objects/something',
+ '.git/refs',
+ '.git/refs/heads',
+ '.git/refs/heads/main',
+ ]
+ const trailing = [...paths, ...paths.map((path) => path + '/')]
+ const forwards = [
+ ...trailing,
+ ...trailing.map((path) => '/' + path),
+ ]
+ for (const path of forwards) {
+ expect(() => fs.write(path, ''), path).toThrow(git)
+ expect(() => fs.write(path, 'data'), path).toThrow(git)
+ expect(() => fs.writeJSON(path, ''), path).toThrow(json)
+ expect(() => fs.writeJSON(path, 'data'), path).toThrow(json)
+ expect(() => fs.delete(path), path).toThrow(git)
+ await expect(fs.read(path), path).rejects.toThrow(git)
+ await expect(fs.readBinary(path), path).rejects.toThrow(git)
+ await expect(fs.readJSON(path), path).rejects.toThrow(json)
+ await expect(fs.ls(path), path).rejects.toThrow(git)
+ await expect(fs.exists(path), path).rejects.toThrow(git)
+ if (path) {
+ expect(() => fs.logs(path), path).toThrow(git)
+ }
+ }
+ })
+ await t.step('complicated paths', async () => {
+ const paths = ['', '.', '/', '/something', '/something/deep', '//something']
+ for (const path of paths) {
+ if (['', '.', '/'].includes(path)) {
+ expect(() => fs.write(path, ''), path).toThrow()
+ expect(() => fs.write(path, 'data'), path).toThrow()
+ expect(() => fs.writeJSON(path, ''), path).toThrow()
+ expect(() => fs.writeJSON(path, 'data'), path).toThrow()
+ expect(() => fs.delete(path), path).toThrow()
+ await expect(fs.ls(path), path).resolves.not.toThrow()
+ await expect(Promise.resolve(fs.logs(path)), path).resolves.not
+ .toThrow()
+ } else {
+ expect(() => fs.delete(path), path).not.toThrow()
+ }
+ await expect(fs.read(path), path).rejects.toThrow()
+ await expect(fs.readBinary(path), path).rejects.toThrow()
+ await expect(fs.readJSON(path), path).rejects.toThrow()
+ await expect(fs.exists(path), path).resolves.not.toThrow()
+ }
+ })
+
+ await t.step('write', async () => {
+ const path = 'hello.txt'
+ const data = 'world'
+
+ await expect(fs.exists(path)).resolves.toBeFalsy()
+ fs.write(path, 'data')
+ await expect(fs.exists(path)).resolves.toBeTruthy()
+ await expect(fs.read(path)).resolves.toBe('data')
+ fs.delete(path)
+ await expect(fs.exists(path)).resolves.toBeFalsy()
+ await expect(fs.read(path)).rejects.toThrow('Could not find file or')
+ fs.write(path, data)
+ await expect(fs.exists(path)).resolves.toBeTruthy()
+ await expect(fs.read(path)).resolves.toBe(data)
+
+ expect(await db.readHead(fs.pid)).toBe(fs.oid)
+ const { next } = await fs.writeCommitObject('write single')
+ expect(await db.readHead(fs.pid), 'commit changed head').toBe(fs.oid)
+
+ const read = await next.read(path)
+ expect(read).toBe(data)
+ await expect(next.exists(path)).resolves.toBeTruthy()
+
+ fs = next
+ })
+ await t.step('write nested', async () => {
+ const path = 'nested/deep/hello.txt'
+ const data = 'world'
+
+ await expect(fs.exists(path)).resolves.toBeFalsy()
+ fs.write(path, 'data')
+ await expect(fs.exists(path)).resolves.toBeTruthy()
+ await expect(fs.read(path)).resolves.toBe('data')
+ fs.delete(path)
+ await expect(fs.exists(path)).resolves.toBeFalsy()
+ await expect(fs.read(path)).rejects.toThrow('Could not find file or')
+ fs.write(path, data)
+ await expect(fs.exists(path)).resolves.toBeTruthy()
+ await expect(fs.read(path)).resolves.toBe(data)
+
+ const { next } = await fs.writeCommitObject('write nested')
+ await expect(next.exists(path)).resolves.toBeTruthy()
+ const read = await next.read(path)
+ expect(read).toBe(data)
+ const oldRead = await next.read('hello.txt')
+ expect(oldRead).toBe(data)
+
+ fs = next
+ })
+ await t.step('logs', async () => {
+ const logs = await fs.logs()
+ expect(logs.length).toBe(3)
+ })
+ await t.step('delete', async () => {
+ const path = 'hello.txt'
+ fs.delete(path)
+ await expect(fs.read(path)).rejects.toThrow('Could not find file or')
+ const { next } = await fs.writeCommitObject('delete')
+ await expect(next.exists(path)).resolves.toBeFalsy()
+ await expect(next.read(path)).rejects.toThrow('Could not find hello.txt')
+
+ fs = next
+ })
+ db.stop()
+})
+Deno.test('clone and pull', async (t) => {
+ const db = await DB.create(DB.generateAesKey())
+ let fs: FS
+ await t.step('clone HAL', async () => {
+ fs = await FS.clone('dreamcatcher-tech/HAL', db)
+ expect(fs.oid).toHaveLength(40)
+ })
+ await t.step('read', async () => {
+ const path = 'README.md'
+ const data = await fs.read(path)
+ expect(data).toContain('AI')
+ })
+ await t.step('fetch', async () => {
+ const oid = await FS.fetch('dreamcatcher-tech/HAL', fs.pid, db)
+ expect(oid).toEqual(fs.oid)
+ })
+
+ // insert the PAT into the github repo
+ // do a push, using this auth method
+
+ // make a new branch
+ // push this up to the git repo for testing
+
+ db.stop()
+})
+Deno.test('merge', async (t) => {
+ const db = await DB.create(DB.generateAesKey())
+ let fs = await FS.init(partialFromRepo('test/merge'), db)
+
+ await t.step('merge', async () => {
+ fs.write('hello.txt', 'world')
+ const { next } = await fs.writeCommitObject('merge')
+ const oid = await next.merge(fs.oid)
+ expect(oid).not.toEqual(fs.oid)
+ fs = next
+ })
+ await t.step('merge conflict', async () => {
+ const readme = await fs.read('hello.txt')
+ expect(readme).toBe('world')
+
+ fs.write('hello.txt', 'conflict 1')
+ const { next } = await fs.writeCommitObject('merge')
+
+ const pid = addPeer(fs.pid, 'conflict')
+ const branch = fs.branch(pid)
+ branch.write('hello.txt', 'conflict 2')
+ const { next: branchNext } = await branch.writeCommitObject('branch')
+
+ const oid = await next.merge(branchNext.oid)
+
+ const merged = FS.open(next.pid, oid, db)
+ const readmeMerged = await merged.read('hello.txt')
+ expect(readmeMerged).toContain('conflict 1')
+ expect(oid).not.toEqual(fs.oid)
+ })
+
+ db.stop()
+})
+Deno.test('overwrite', async () => {
+ const db = await DB.create(DB.generateAesKey())
+ const pid = partialFromRepo('test/merge')
+ const base = await FS.init(pid, db)
+ base.write(IO_PATH, '0')
+ base.write('a.txt', 'a')
+ base.write('b.txt', 'b')
+ base.write('c/c.txt', 'c')
+ base.write('c/d.txt', 'd')
+ const { next } = await base.writeCommitObject('initial')
+ const childPid = addBranches(next.pid, 'child')
+ const branch = next.branch(childPid)
+
+ branch.write(IO_PATH, '1')
+ branch.write('a.txt', 'A')
+ branch.delete('c/c.txt')
+ branch.write('c/e.txt', 'e')
+ branch.write('c/d.txt', 'D')
+ const { next: branchNext } = await branch.writeCommitObject('branch')
+
+ await next.overwrite(branchNext.oid, 'c/c.txt')
+ expect(await next.read(IO_PATH)).toBe('0')
+ expect(await branchNext.read(IO_PATH)).toBe('1')
+
+ expect(await next.read('a.txt')).toBe('A')
+ expect(await next.read('b.txt')).toBe('b')
+ expect(await next.read('c/c.txt')).toBe('c')
+ expect(await branchNext.exists('c/c.txt')).toBeFalsy()
+ expect(await next.read('c/d.txt')).toBe('D')
+ expect(await next.read('c/e.txt')).toBe('e')
+
+ db.stop()
+})
+// TODO block isolates from accessing .git paths
+
+// check that a nonexistent pid throws
+// TODO test writing a file that hashes to the same as the existing one
+// this should result in no commit being made. IO always changes, so this
+// should still commit, but there should be no other file changes attempted.
diff --git a/_import-artifact/git/fs.ts b/_import-artifact/git/fs.ts
new file mode 100644
index 000000000000..f15ace234f17
--- /dev/null
+++ b/_import-artifact/git/fs.ts
@@ -0,0 +1,717 @@
+import diff3Merge from 'diff3'
+import http from '$git/http/web/index.js'
+import { assert, Debug, equal, posix } from '@utils'
+import {
+ Change,
+ ENTRY_BRANCH,
+ IO_PATH,
+ isBaseRepo,
+ PartialPID,
+ PID,
+ print,
+ randomness,
+ sha1,
+ type TreeEntry,
+} from '@/constants.ts'
+import git, { Errors, type MergeDriverCallback } from '$git'
+import type DB from '@/db.ts'
+import { GitKV } from './gitkv.ts'
+const log = Debug('git:fs')
+const dir = '/'
+
+type Upsert = { oid: string } | { data: string | Uint8Array }
+
+export default class FS {
+ readonly #pid: PID
+ readonly #oid: string
+ readonly #gitkv: GitKV
+ readonly #db: DB
+ readonly #upserts = new Map()
+ readonly #deletes = new Set()
+ /** If present, the commit oid that overwrote the current FS */
+ #overwrite: string | undefined
+
+ static #caches = new Map()
+ static #getGitCache(pid: PID) {
+ if (!FS.#caches.has(pid.repoId)) {
+ FS.#caches.set(pid.repoId, {})
+ }
+ const cache = FS.#caches.get(pid.repoId)
+ assert(cache)
+ return cache
+ }
+ static clearCache(pid: PID) {
+ FS.#caches.delete(pid.repoId)
+ }
+ get #git() {
+ const cache = FS.#getGitCache(this.#pid)
+ return { fs: this.fs, dir, cache }
+ }
+ get pid() {
+ return this.#pid
+ }
+ /** The oid used as the root git directory */
+ get #internalOid() {
+ return this.#overwrite || this.oid
+ }
+ /** The commit oid backing this filesystem */
+ get oid() {
+ return this.#oid
+ }
+ get fs() {
+ return { promises: this.#gitkv }
+ }
+ get isChanged() {
+ return this.#overwrite || this.#upserts.size > 0 || this.#deletes.size > 0
+ }
+ get upserts() {
+ return [...this.#upserts.keys()]
+ }
+ get deletes() {
+ return [...this.#deletes]
+ }
+ private constructor(pid: PID, oid: string, db: DB) {
+ assert(sha1.test(oid), 'Commit not SHA-1: ' + oid)
+ this.#pid = pid
+ this.#oid = oid
+ this.#db = db
+ this.#gitkv = GitKV.recreate(db, pid)
+ }
+ static open(pid: PID, commit: string, db: DB) {
+ return new FS(pid, commit, db)
+ }
+ static async openHead(pid: PID, db: DB) {
+ const head = await db.readHead(pid)
+ if (!head) {
+ throw new Error('HEAD not found: ' + print(pid))
+ }
+ return new FS(pid, head, db)
+ }
+ static async init(partial: PartialPID, db: DB, owner?: PID) {
+ const repoId = generateFakeRepoId()
+ const pid = { ...partial, repoId }
+ const fs = { promises: GitKV.createBlank(db, pid) }
+ assert(isBaseRepo(pid), 'not a base repo: ' + print(pid))
+
+ await git.init({ fs, dir, defaultBranch: pid.branches[0] })
+ log('init complete')
+ const author = { name: owner ? print(owner) : 'git/init' }
+ const cache = FS.#getGitCache(pid)
+ // TODO insert the .io.json file that includes the consensus config
+ // TODO write owner into config
+ const commit = await git.commit({
+ noUpdateBranch: true,
+ fs,
+ dir,
+ message: 'initial commit',
+ author,
+ cache,
+ })
+ await db.atomic().createBranch(pid, commit).commit()
+ const init = new FS(pid, commit, db)
+ return init
+ }
+ static async clone(repo: string, db: DB) {
+ // TODO lock the whole repo in case something is running
+ // TODO detect the main branch from remote/HEAD
+ assert(repo.split('/').length === 2, 'invalid repo: ' + repo)
+ const url = `https://github.com/${repo}.git`
+
+ const repoId = generateFakeRepoId()
+ const [account, repository] = repo.split('/')
+ const pid = { repoId, account, repository, branches: [ENTRY_BRANCH] }
+ const fs = { promises: GitKV.createBlank(db, pid) }
+
+ fs.promises.oneAtomicWrite = db.atomic()
+ const cache = FS.#getGitCache(pid)
+ await git.clone({ fs, dir, url, http, noCheckout: true, cache })
+ const commit = await db.readHead(pid)
+ assert(commit, 'HEAD not found: ' + pid.branches.join('/'))
+ const clone = new FS(pid, commit, db)
+ return clone
+ }
+ static async fetch(repo: string, pid: PID, db: DB) {
+ assert(repo.split('/').length === 2, 'invalid repo: ' + repo)
+ const url = `https://github.com/${repo}.git`
+
+ const lockId = await db.lockRepo(pid)
+ try {
+ const { fs } = await FS.openHead(pid, db)
+ const cache = FS.#getGitCache(pid)
+ const result = await git.fetch({ fs, http, dir, url, cache })
+ const { fetchHead } = result
+ assert(fetchHead, 'fetchHead not found')
+
+ // TODO make release be atomic
+ return fetchHead
+ } finally {
+ await db.releaseRepoLock(pid, lockId)
+ }
+ }
+ static async push(repo: string, pid: PID, db: DB) {
+ assert(repo.split('/').length === 2, 'invalid repo: ' + repo)
+ const url = `https://github.com/${repo}.git`
+ assert(isBaseRepo(pid), 'not a base repo: ' + print(pid))
+ const { fs } = await FS.openHead(pid, db)
+ const cache = FS.#getGitCache(pid)
+ const result = await git.push({ fs, http, dir, url, cache })
+ const { ok } = result
+ if (!ok) {
+ throw new Error('push failed')
+ }
+ }
+
+ tick(commit: string) {
+ return new FS(this.#pid, commit, this.#db)
+ }
+ /** @param the new PID to branch into */
+ branch(pid: PID) {
+ assert(isSameRepo(this.#pid, pid), 'branching into a different repo')
+ return new FS(pid, this.oid, this.#db)
+ }
+ logs(filepath?: string, depth?: number) {
+ if (filepath) {
+ filepath = refine(filepath)
+ }
+ if (filepath === '.') {
+ filepath = undefined
+ }
+ return git.log({ ...this.#git, filepath, depth, ref: this.oid })
+ }
+
+ async writeCommitObject(message = '', parents: string[] = []) {
+ assert(this.isChanged, 'empty commit')
+ assert(parents.every((oid) => sha1.test(oid)), 'Parent not SHA-1')
+ const { oid, changes } = await this.#flush()
+ this.#upserts.clear()
+ this.#deletes.clear()
+
+ const author = { name: 'git/commit' }
+ const nextCommit = await git.commit({
+ ...this.#git,
+ noUpdateBranch: true,
+ message,
+ author,
+ tree: oid,
+ parent: [this.oid, ...parents],
+ })
+ const { commit } = await git.readCommit({ ...this.#git, oid: nextCommit })
+
+ const next = new FS(this.#pid, nextCommit, this.#db)
+ return { next, changes, commit }
+ }
+ async theirsMerge(theirs: string) {
+ const parents = [theirs]
+ assert(parents.every((oid) => sha1.test(oid)), 'Parent not SHA-1')
+ assert(!this.isChanged, 'cannot merge with changes')
+ if (this.oid === theirs) {
+ throw new Error('Already merged')
+ }
+ const author = { name: 'git/theirsMerge' }
+
+ const theirTree = await git.readTree({ ...this.#git, oid: theirs })
+ const ourTree = await git.readTree({ ...this.#git, oid: this.oid })
+
+ const io = ourTree.tree.find((entry) => entry.path === IO_PATH)
+ const merged = theirTree.tree.filter((entry) => entry.path !== IO_PATH)
+ if (io) {
+ merged.push(io)
+ }
+ const tree = await git.writeTree({ ...this.#git, tree: merged })
+
+ const commit = await git.commit({
+ ...this.#git,
+ noUpdateBranch: true,
+ message: 'Merge using "theirs" strategy',
+ author,
+ tree,
+ parent: [this.oid, ...parents],
+ })
+
+ const next = new FS(this.#pid, commit, this.#db)
+ return { next, changes: {}, commit }
+ }
+ async merge(commit: string) {
+ assert(!this.isChanged, 'cannot merge with changes')
+ if (this.oid === commit) {
+ return this.oid
+ }
+ const result = await git.merge({
+ ...this.#git,
+ noUpdateBranch: true,
+ mergeDriver,
+ ours: this.oid,
+ theirs: commit,
+ author: { name: 'Artifact' },
+ message: 'Merge',
+ })
+ assert(result.oid, 'merge failed')
+ return result.oid
+ }
+ async exists(path: string) {
+ path = refine(path)
+ if (path === '.') {
+ return true
+ }
+ if (this.#deletes.has(path)) {
+ return false
+ }
+ if (this.#upserts.has(path)) {
+ return true
+ }
+
+ try {
+ await this.readOid(path)
+ return true
+ } catch (error) {
+ // TODO move all errors to be FileNotFoundError
+ if (
+ error instanceof Error && 'code' in error &&
+ error.code === 'NotFoundError'
+ ) {
+ return false
+ }
+ throw error
+ }
+ }
+
+ async readOid(path: string): Promise {
+ // TODO test how this works for "."
+ path = refine(path)
+ if (this.#deletes.has(path)) {
+ throw new Errors.NotFoundError(path)
+ }
+
+ const dirname = posix.dirname(path)
+ const basename = posix.basename(path)
+ const tree = await this.readTree(dirname)
+ for (const entry of tree) {
+ if (entry.path === basename) {
+ return entry.oid
+ }
+ }
+ throw new Errors.NotFoundError(path)
+ }
+ async readTree(path: string = '.') {
+ path = refine(path)
+ const oid = this.#internalOid
+ const filepath = path === '.' ? undefined : path
+ try {
+ const { tree } = await git.readTree({ ...this.#git, oid, filepath })
+ return tree
+ } catch (error) {
+ if (
+ error instanceof Error && 'code' in error &&
+ error.code === 'NotFoundError'
+ ) {
+ // remove the git commit hash from the error so it is repeatable
+ throw new Errors.NotFoundError(path)
+ }
+ throw error
+ }
+ }
+ delete(path: string) {
+ path = refine(path)
+ assert(path !== '.', 'cannot delete root')
+ // TODO delete a whole directory
+ log('delete', path)
+ this.#deletes.add(path)
+ this.#upserts.delete(path)
+ }
+ writeJSON(path: string, json: unknown) {
+ // TODO store json objects specially, only strinify on commit
+ // then broadcast changes as json object purely
+ assert(posix.extname(path) === '.json', `path must be *.json: ${path}`)
+ path = refine(path)
+ const string = JSON.stringify(json, null, 2)
+ assert(typeof string === 'string', 'stringify failed')
+ return this.write(path, string)
+ }
+ write(path: string, data: string | Uint8Array) {
+ path = refine(path)
+ assert(path !== '.', 'cannot write to root')
+ // TODO ensure cannot write to a directory
+ log('write', path, data)
+ this.#upserts.set(path, { data })
+ this.#deletes.delete(path)
+ }
+ async readJSON(path: string, commit?: string): Promise {
+ assert(posix.extname(path) === '.json', `path must be *.json: ${path}`)
+ const data = await this.read(path, commit)
+ return JSON.parse(data)
+ }
+ async read(path: string, commit?: string) {
+ const blob = await this.readBinary(path, commit)
+ return new TextDecoder().decode(blob)
+ }
+ async readBinary(path: string, commit?: string): Promise {
+ path = refine(path)
+ log('readBinary', path, commit)
+
+ if (commit) {
+ const { blob } = await this.#readBlob(path, commit)
+ return blob
+ }
+
+ if (this.#deletes.has(path)) {
+ throw new Error('Could not find file or directory: ' + path)
+ }
+ if (this.#upserts.has(path)) {
+ const upsert = this.#upserts.get(path)
+ assert(upsert, 'upsert not found')
+ if ('data' in upsert) {
+ if (typeof upsert.data === 'string') {
+ return new TextEncoder().encode(upsert.data)
+ }
+ return upsert.data
+ } else {
+ const { oid } = upsert
+ const { blob } = await this.#safeReadBlob({ oid })
+ return blob
+ }
+ }
+ const { blob } = await this.#readBlob(path)
+ return blob
+ }
+ async #readBlob(filepath: string, commit?: string) {
+ const { blob, oid } = await this.#safeReadBlob({
+ oid: commit || this.#internalOid,
+ filepath,
+ })
+ assert(blob instanceof Uint8Array, 'blob not Uint8Array: ' + typeof blob)
+ return { blob, oid }
+ }
+ async #safeReadBlob(params: { oid: string; filepath?: string }) {
+ try {
+ const { oid, filepath } = params
+ return await git.readBlob({ ...this.#git, oid, filepath })
+ } catch (error) {
+ if (
+ error instanceof Error && 'code' in error &&
+ error.code === 'NotFoundError'
+ ) {
+ throw new Errors.NotFoundError(params.filepath || '.')
+ }
+ throw error
+ }
+ }
+
+ async ls(path: string = '.') {
+ path = refine(path)
+ // TODO make a streaming version of this for very large dirs
+ // TODO handle changes in the directory like deletes and upserts
+ log('ls', path)
+ const filepath = path === '.' ? undefined : path
+ const tree = await this.readTree(filepath)
+
+ tree.sort((a, b) => {
+ if (a.type === 'tree' && b.type === 'blob') {
+ return -1
+ }
+ if (a.type === 'blob' && b.type === 'tree') {
+ return 1
+ }
+ if (a.path.startsWith('.') && !b.path.startsWith('.')) {
+ return -1
+ }
+ if (!a.path.startsWith('.') && b.path.startsWith('.')) {
+ return 1
+ }
+ return a.path.localeCompare(b.path)
+ })
+ return tree.map((entry) => {
+ if (entry.type === 'tree') {
+ return entry.path + '/'
+ }
+ assert(entry.type === 'blob', 'entry type not blob: ' + entry.type)
+ return entry.path
+ })
+ }
+ async getCommit() {
+ const result = await git.readCommit({ ...this.#git, oid: this.oid })
+ return result.commit
+ }
+ copyChanges(from: FS) {
+ assert(!this.isChanged, 'cannot copy changes to a changed FS')
+ assert(equal(this.#pid, from.#pid), 'changes are from different pids')
+ for (const path of from.#deletes) {
+ this.#deletes.add(path)
+ }
+ for (const [path, upsert] of from.#upserts) {
+ this.#upserts.set(path, upsert)
+ }
+ this.#overwrite = from.#overwrite
+ }
+ async isPidExists(pid: PID) {
+ // TODO maybe if this gets read, it gets stored in the accumulator
+ // store the root head of our repo in the git file structure, used to
+ // reference from
+ return !!await this.#db.readHead(pid)
+ }
+ async mv(from: string, to: string) {
+ await this.cp(from, to)
+ this.delete(from)
+ }
+ async cp(from: string, to: string) {
+ // TODO check using directories
+ from = refine(from)
+ to = refine(to)
+ assert(from !== to, 'source and destination are the same')
+ assert(await this.exists(from), 'source does not exist: ' + from)
+ assert(!await this.exists(to), 'destination already exists: ' + to)
+ const oid = await this.readOid(from)
+ this.#upserts.set(to, { oid })
+ }
+ async overwrite(commit: string, ...ignores: string[]) {
+ // TODO allow changes so long as they are in the ignored set
+ assert(!this.isChanged, 'Uncommitted changes may be lost')
+ assert(sha1.test(commit), 'Commit not SHA-1: ' + commit)
+ assert(this.oid !== commit, 'cannot overwrite with same commit')
+ assert(this.#overwrite !== commit, 'cannot overwrite the same commit twice')
+ ignores.push(IO_PATH)
+ ignores.forEach(refine)
+
+ const result = await git.readCommit({ ...this.#git, oid: commit })
+ assert(result, 'commit not found: ' + commit)
+
+ for (const ignore of ignores) {
+ if (this.#upserts.has(ignore)) {
+ continue
+ }
+ if (this.#deletes.has(ignore)) {
+ continue
+ }
+ if (await this.exists(ignore)) {
+ const oid = await this.readOid(ignore)
+ // TODO check if it is unchanged that this is handled
+ this.#upserts.set(ignore, { oid })
+ } else {
+ // TODO check that deleting something not present is handled
+ this.#deletes.add(ignore)
+ }
+ }
+
+ this.#overwrite = commit
+ }
+ async #flush() {
+ const changes: { [key: string]: Change } = {}
+ const oid = this.#internalOid
+ const { tree: base } = await git.readTree({ ...this.#git, oid })
+ log('flush tree', base)
+ const tree: Tree = {
+ oid,
+ tree: base,
+ upserts: new Map(),
+ deletes: new Set(),
+ children: new Map(),
+ }
+ for (const [path, upsert] of this.#upserts) {
+ let patch: string | undefined
+ let blob: Uint8Array
+ let oid: string
+ if ('data' in upsert) {
+ if (typeof upsert.data === 'string') {
+ patch = upsert.data
+ blob = new TextEncoder().encode(upsert.data)
+ } else {
+ blob = upsert.data
+ }
+ oid = await git.writeBlob({ ...this.#git, blob })
+ } else {
+ oid = upsert.oid
+ }
+ // TODO parallelize
+ log('hash', oid)
+ const parent = ensurePath(tree, path)
+ const filename = path.split('/').pop()
+ assert(filename, 'filename not found: ' + path)
+ // TODO ignore if already exists
+ parent.upserts.set(filename, {
+ // https://isomorphic-git.org/docs/en/walk#walkerentry-mode
+ mode: '100644',
+ path: filename,
+ oid,
+ type: 'blob',
+ })
+ changes[path] = { oid, patch }
+ }
+
+ for (const path of this.#deletes) {
+ log('delete', path)
+ const parent = ensurePath(tree, path)
+ const filename = path.split('/').pop()
+ assert(filename, 'filename not found: ' + path)
+ parent.deletes.add(filename)
+ changes[path] = {}
+ // TODO should be able to wipe a whole dir with no effort here
+ }
+
+ await retrieveAffectedTrees(tree, this.#git)
+
+ await bubbleChanges(tree, this.#git)
+
+ return { oid: tree.oid, changes }
+ }
+}
+type Tree = {
+ oid?: string
+ tree?: TreeObject
+ upserts: Map
+ deletes: Set
+ children: Map
+}
+type TreeObject = TreeEntry[]
+
+const ensurePath = (tree: Tree, path: string) => {
+ const parts = path.split('/')
+ parts.pop()
+ let parent = tree
+ for (let i = 0; i < parts.length; i++) {
+ const part = parts[i]
+ let child = parent.children.get(part)
+ if (!child) {
+ child = {
+ upserts: new Map(),
+ deletes: new Set(),
+ children: new Map(),
+ }
+ parent.children.set(part, child)
+ }
+ parent = child
+ }
+ return parent
+}
+type Opts = { fs: { promises: GitKV }; cache: object; dir: string }
+const retrieveAffectedTrees = async (tree: Tree, opts: Opts) => {
+ const promises = []
+ if (!tree.tree) {
+ assert(tree.oid, 'tree oid not found')
+ const result = await git.readTree({ ...opts, oid: tree.oid })
+ tree.tree = result.tree
+ }
+ for (const entry of tree.tree) {
+ if (entry.type === 'tree') {
+ if (tree.children.has(entry.path)) {
+ const child = tree.children.get(entry.path)
+ assert(child, 'child not found: ' + entry.path)
+ child.oid = entry.oid
+ promises.push(retrieveAffectedTrees(child, opts))
+ }
+ }
+ }
+ await Promise.all(promises)
+}
+const bubbleChanges = async (tree: Tree, opts: Opts) => {
+ const layers = treeToLayers(tree)
+ log('layers', layers)
+ while (layers.length) {
+ const layer = layers.pop()
+ for (const item of layer!) {
+ let tree = item.tree || []
+ tree = tree.filter((entry) => {
+ if (item.upserts.has(entry.path)) {
+ return false
+ }
+ if (item.deletes.has(entry.path)) {
+ return false
+ }
+ if (item.children.has(entry.path)) {
+ return false
+ }
+ return true
+ })
+ for (const [, entry] of item.upserts) {
+ tree.push(entry)
+ }
+ for (const [path, child] of item.children) {
+ assert(child.oid, 'child oid not found: ' + path)
+ const entry: TreeEntry = {
+ mode: '040000',
+ path,
+ oid: child.oid,
+ type: 'tree',
+ }
+ tree.push(entry)
+ }
+ item.oid = await git.writeTree({ ...opts, tree })
+ log('write tree', item.oid)
+ }
+ }
+}
+
+const treeToLayers = (tree: Tree, layers: Tree[][] = [], level: number = 0) => {
+ if (!layers[level]) {
+ layers[level] = []
+ }
+ layers[level].push(tree)
+ for (const child of tree.children.values()) {
+ treeToLayers(child, layers, level + 1)
+ }
+ return layers
+}
+const refine = (path: string) => {
+ path = path.trim()
+ while (path.startsWith('/')) {
+ path = path.slice(1)
+ }
+ while (path.endsWith('/')) {
+ path = path.slice(0, -1)
+ }
+ while (path.startsWith('./')) {
+ path = path.slice(2)
+ }
+ if (!path) {
+ path = '.'
+ }
+ path = posix.normalize(path)
+ assert(path, `path must be relative: ${path}`)
+ assert(!posix.isAbsolute(path), `path must be relative: ${path}`)
+ assert(path !== '.git', '.git paths are forbidden: ' + path)
+ assert(!path.startsWith('.git/'), '.git paths are forbidden: ' + path)
+ assert(!path.endsWith('/'), 'path must not end with /: ' + path)
+ assert(!path.startsWith('..'), 'path must not start with ..: ' + path)
+ return path
+}
+
+const generateFakeRepoId = () => {
+ // TODO make this genuine based on the genesis commit
+ return `rep_${randomness()}`
+}
+
+const mergeDriver: MergeDriverCallback = ({ contents, path }) => {
+ const baseContent = contents[0]
+ const ourContent = contents[1]
+ const theirContent = contents[2]
+
+ if (path === IO_PATH) {
+ return { cleanMerge: true, mergedText: ourContent }
+ }
+
+ const LINEBREAKS = /^.*(\r?\n|$)/gm
+ const ours = ourContent.match(LINEBREAKS)
+ const base = baseContent.match(LINEBREAKS)
+ const theirs = theirContent.match(LINEBREAKS)
+ const result = diff3Merge(ours, base, theirs)
+ let mergedText = ''
+ for (const item of result) {
+ if (item.ok) {
+ mergedText += item.ok.join('')
+ }
+ if (item.conflict) {
+ mergedText += item.conflict.a.join('')
+ }
+ }
+ return { cleanMerge: true, mergedText }
+}
+const isSameRepo = (a: PID, b: PID) => {
+ if (a.repoId !== b.repoId) {
+ return false
+ }
+ if (a.account !== b.account) {
+ return false
+ }
+ if (a.repository !== b.repository) {
+ return false
+ }
+ return true
+}
diff --git a/_import-artifact/git/gitkv.ts b/_import-artifact/git/gitkv.ts
new file mode 100644
index 000000000000..78b2b683fd55
--- /dev/null
+++ b/_import-artifact/git/gitkv.ts
@@ -0,0 +1,293 @@
+import { Debug } from '@utils'
+import { getRepoBase, headKeyToPid } from '@/keys.ts'
+import type DB from '@/db.ts'
+import { assert, AssertionError, equal } from '@utils'
+import { PID } from '@/constants.ts'
+import { Atomic } from '@/atomic.ts'
+
+const log = Debug('git:KV')
+
+export class GitKV {
+ #allowed = ['config', 'objects', 'refs']
+ #dropWrites = ['HEAD']
+ #db: DB
+ #pid: PID
+ #exists: Set | undefined
+ #cache = Cache.create()
+
+ private constructor(db: DB, pid: PID, isBlank: boolean = false) {
+ this.#db = db
+ this.#pid = pid
+ if (isBlank) {
+ this.#exists = new Set()
+ }
+ }
+ static recreate(db: DB, pid: PID) {
+ return new GitKV(db, pid)
+ }
+ static createBlank(db: DB, pid: PID) {
+ const isBlankDuringInitAndClone = true
+ return new GitKV(db, pid, isBlankDuringInitAndClone)
+ }
+
+ isIgnored(path: string) {
+ const sliced = path.slice('/.git/'.length)
+ return this.#dropWrites.includes(sliced)
+ }
+ async readFile(path: string, opts: EncodingOpts) {
+ log('readFile', path, opts)
+ if (!path && !opts) {
+ throw new Error('path and opts are required')
+ }
+ if (path === '/.git/index') {
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ if (path === '/.git/HEAD') {
+ let ref = `ref: refs/heads`
+ for (const branch of this.#pid.branches) {
+ ref += `/${branch}`
+ }
+ log('readFile HEAD ref', ref)
+ return ref
+ }
+ if (this.#exists && !this.#exists.has(path)) {
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ if (path.startsWith('/.git/refs/heads/')) {
+ // only allow reading heads from the current branch, else what doing ?
+ const rest = path.slice('/.git/refs/heads/'.length)
+ const branches = rest.split('/')
+ log('readFile refs/heads:', branches)
+ assert(equal(branches, this.#pid.branches), 'branches do not match')
+ const head = await this.#db.readHead(this.#pid)
+ if (!head) {
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ return head
+ }
+
+ if (opts && opts.encoding && opts.encoding !== 'utf8') {
+ throw new Error('only utf8 encoding is supported')
+ }
+
+ const pathKey = this.#getAllowedPathKey(path)
+ let result: Uint8Array
+ if (await this.#cache.has(pathKey)) {
+ result = this.#cache.get(pathKey)
+ } else {
+ const dbResult = await this.#db.blobGet(pathKey)
+
+ if (!dbResult.versionstamp) {
+ log('readFile not found', path, opts)
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ result = dbResult.value
+ await this.#cache.set(pathKey, result)
+ }
+ if (opts && opts.encoding === 'utf8') {
+ const string = new TextDecoder().decode(result)
+ log('readFile', path, opts, string)
+ return string
+ }
+ log('readFile', path, opts, typeof result)
+ return result
+ }
+ async writeFile(
+ path: string,
+ data: Uint8Array | string,
+ opts: EncodingOpts,
+ ) {
+ log('writeFile', path, data, opts)
+ if (opts && opts.encoding && opts.encoding !== 'utf8') {
+ throw new Error('only utf8 encoding is supported')
+ }
+ if (this.isIgnored(path)) {
+ log('writeFile ignored', path)
+ return
+ }
+ if (path === '/.git/index') {
+ throw new Error('will not write to index')
+ }
+ if (this.#exists) {
+ this.#exists.add(path)
+ }
+ const pathKey = this.#getAllowedPathKey(path)
+
+ // TODO skip the remote HEAD writes too ?
+ if (path.startsWith('/.git/refs/heads/')) {
+ // TODO use the head tool on this.#db to ensure consistency
+ assert(typeof data === 'string', 'data must be a string')
+ const pid = headKeyToPid(pathKey)
+ // TODO ensure have maintenance while this is being changed
+ assert(this.#oneAtomicWrite, 'no atomic write provided')
+ const atomic = this.#oneAtomicWrite
+ this.#oneAtomicWrite = undefined
+ await atomic.createBranch(pid, data.trim()).commit()
+ } else {
+ if (typeof data === 'string') {
+ data = new TextEncoder().encode(data)
+ }
+ const promise = this.#cache.set(pathKey, data)
+ await this.#db.blobSet(pathKey, data)
+ await promise
+ }
+ log('writeFile done:', pathKey)
+ }
+ #oneAtomicWrite: Atomic | undefined
+ set oneAtomicWrite(atomic: Atomic) {
+ this.#oneAtomicWrite = atomic
+ }
+ async unlink(path: string) {
+ log('unlink', path)
+ if (path === '/.git/shallow') {
+ return
+ }
+ return await Promise.reject(new Error('not implemented'))
+ }
+ async readdir(path: string, options?: object) {
+ log('readdir', path)
+ assert(!options, 'options not supported')
+ let pathKey = getRepoBase(this.#pid)
+ if (path !== '/.git') {
+ pathKey = this.#getAllowedPathKey(path)
+ }
+ const results = await this.#db.listImmediateChildren(pathKey)
+ log('readdir', path, results)
+
+ return results
+ }
+ mkdir(path: string) {
+ log('mkdir', path)
+ return Promise.resolve()
+ }
+ async rmdir(path: string) {
+ log('rmdir', path)
+ return await Promise.reject(new Error('not implemented'))
+ }
+ async stat(path: string) {
+ log('stat', path)
+ // generate the key for the path
+ let pathKey
+ try {
+ pathKey = this.#getAllowedPathKey(path)
+ } catch (error) {
+ if (error instanceof AssertionError) {
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ throw error
+ }
+ if (this.#exists && !this.#exists.has(path)) {
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ log('stat pathKey', pathKey)
+ let exists = false
+ if (path.startsWith('/.git/refs/heads/')) {
+ const pid = headKeyToPid(pathKey)
+ const head = await this.#db.readHead(pid)
+ exists = !!head
+ } else {
+ if (await this.#cache.has(pathKey)) {
+ exists = true
+ } else {
+ if (path.startsWith('/.git/objects/')) {
+ // wastes a round trip to the db otherwise
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ exists = await this.#db.blobExists(pathKey)
+ }
+ }
+ if (!exists) {
+ throw new FileNotFoundError('file not found: ' + path)
+ }
+ return {}
+ }
+ async lstat(path: string) {
+ log('lstat', path)
+ const message = 'not implemented: ' + path
+ return await Promise.reject(new FileNotFoundError(message))
+ }
+ async readlink(path: string) {
+ log('readlink', path)
+ return await Promise.reject(new Error('not implemented'))
+ }
+ async symlink(target: string, path: string, type: string) {
+ log('symlink', target, path, type)
+ return await Promise.reject(new Error('not implemented'))
+ }
+ async chmod(path: string, mode: number) {
+ log('chmod', path, mode)
+ return await Promise.reject(new Error('not implemented'))
+ }
+ #getAllowedPathKey(path: string) {
+ assert(path.startsWith('/.git/'), 'path must start with /.git/')
+ const rest = path.slice('/.git/'.length)
+ assert(rest, 'path must not be bare')
+ const prefix = getRepoBase(this.#pid)
+ const pathKey = rest.split('/')
+ assert(this.#allowed.includes(pathKey[0]), 'path not allowed: ' + pathKey)
+
+ return [...prefix, ...pathKey]
+ }
+}
+
+type EncodingOpts = {
+ encoding?: 'utf8'
+}
+
+export class FileNotFoundError extends Error {
+ code = 'ENOENT'
+ constructor(message: string) {
+ super(message)
+ this.name = 'FileNotFoundError'
+ }
+}
+class Cache {
+ static create() {
+ return new Cache()
+ }
+ static #local = new Map()
+ #big: globalThis.Cache | undefined
+ async #load() {
+ if ('caches' in globalThis && !this.#big) {
+ // TODO name the caches per repo so they can be deleted granularly
+ this.#big = await caches.open('hashbucket')
+ }
+ }
+ async has(key: Deno.KvKey) {
+ const url = toUrl(key)
+ if (Cache.#local.has(url)) {
+ return true
+ }
+
+ await this.#load()
+ if (this.#big) {
+ const cached = await this.#big.match(url)
+ if (cached) {
+ const cloned = cached.clone()
+ const bytes = await cloned.bytes()
+ Cache.#local.set(url, bytes)
+ return true
+ }
+ }
+ return false
+ }
+ get(key: Deno.KvKey) {
+ const url = toUrl(key)
+ if (Cache.#local.has(url)) {
+ const result = Cache.#local.get(url)
+ assert(result, 'cache inconsistency')
+ return result
+ }
+ throw new Error('not found: ' + key.join('/'))
+ }
+ async set(key: Deno.KvKey, value: Uint8Array) {
+ await this.#load()
+ const url = toUrl(key)
+ Cache.#local.set(url, value)
+ if (this.#big) {
+ const request = new Request(url)
+ await this.#big.put(request, new Response(value))
+ }
+ }
+}
+const toUrl = (pathKey: Deno.KvKey) => 'http://' + pathKey.join('/')
diff --git a/_import-artifact/git/serial.test.ts b/_import-artifact/git/serial.test.ts
new file mode 100644
index 000000000000..dc7681446715
--- /dev/null
+++ b/_import-artifact/git/serial.test.ts
@@ -0,0 +1,136 @@
+import { assert, expect, log } from '@utils'
+import { solidify } from '@/git/solidify.ts'
+import {
+ IoStruct,
+ MergeReply,
+ PartialPID,
+ PID,
+ Pierce,
+ Proctype,
+ UnsequencedRequest,
+} from '@/constants.ts'
+import FS from './fs.ts'
+import DB from '@/db.ts'
+
+Deno.test('pierce serial', async (t) => {
+ const db = await DB.create(DB.generateAesKey())
+ const partial: PartialPID = {
+ account: 'git',
+ repository: 'test',
+ branches: ['main'],
+ }
+ let fs = await FS.init(partial, db)
+ const target: PID = fs.pid
+ const mockRequest: UnsequencedRequest = {
+ target,
+ isolate: 'mock',
+ functionName: 'mock',
+ params: {},
+ proctype: Proctype.enum.SERIAL,
+ }
+ // TODO move away from using pierces to test these functions
+ const pierceFactory = (ulid: string): Pierce => ({
+ target,
+ ulid,
+ isolate: 'test-isolate',
+ functionName: 'test',
+ params: { request: mockRequest },
+ proctype: Proctype.enum.SERIAL,
+ })
+ const reply: MergeReply = {
+ target,
+ sequence: 0,
+ outcome: { result: 'test-result' },
+ source: target,
+ commit: '4b825dc642cb6eb9a060e54bf8d69288fbee4904',
+ }
+ await t.step('init', async () => {
+ const logs = await fs.logs()
+ expect(logs).toHaveLength(1)
+ expect(fs.pid).toEqual(target)
+ })
+ const pierce = pierceFactory('pierce')
+ await t.step('pierce', async () => {
+ const { exe, oid } = await solidify(fs, [pierce])
+ assert(exe)
+ expect(exe.request).not.toHaveProperty('ulid')
+
+ fs = FS.open(fs.pid, oid, db)
+ const io = await fs.readJSON('.io.json')
+ log('io', io)
+ expect(io.sequence).toBe(1)
+ expect(io.requests[0]).toEqual(pierce)
+ })
+ await t.step('pierce reply', async () => {
+ const { oid, poolables, exe } = await solidify(fs, [reply])
+ expect(oid).not.toBe(fs.oid)
+ expect(exe).toBeUndefined()
+ expect(poolables).toHaveLength(0)
+
+ fs = FS.open(fs.pid, oid, db)
+ const io = await fs.readJSON('.io.json')
+ log('io', io)
+ expect(io.sequence).toBe(1)
+ expect(io.replies[0]).toEqual(reply.outcome)
+ })
+ await t.step('second action blanks io', async () => {
+ const { oid, exe } = await solidify(fs, [pierce])
+ expect(oid).not.toBe(fs.oid)
+ expect(exe).toBeDefined()
+
+ fs = FS.open(fs.pid, oid, db)
+ const io = await fs.readJSON('.io.json')
+ log('io', io)
+ expect(io.sequence).toBe(2)
+ expect(io.requests[0]).toBeUndefined()
+ expect(io.requests[1]).toEqual(pierce)
+ expect(io.replies[0]).toBeUndefined()
+ })
+ await t.step('multiple requests', async () => {
+ const { oid, exe } = await solidify(fs, [
+ pierceFactory('a'),
+ pierceFactory('b'),
+ ])
+ expect(oid).not.toBe(fs.oid)
+ expect(exe).toBeUndefined()
+
+ fs = FS.open(fs.pid, oid, db)
+ const io = await fs.readJSON('.io.json')
+ expect(io.sequence).toBe(4)
+ expect(Object.keys(io.requests).length).toBe(3)
+ expect(io.replies).toEqual({})
+ })
+ await t.step('multiple replies', async () => {
+ const pool = replies(1, 3)
+ const { oid } = await solidify(fs, pool)
+ expect(oid).not.toBe(fs.oid)
+
+ fs = FS.open(fs.pid, oid, db)
+ const io = await fs.readJSON('.io.json')
+ expect(io.sequence).toBe(4)
+ expect(Object.keys(io.requests).length).toBe(3)
+ expect(Object.keys(io.replies).length).toEqual(3)
+ })
+ db.stop()
+ // TODO cannot reply out of order
+ // TODO permissioning for inclusion in the pool
+})
+const replies = (start: number, end: number) => {
+ const pool: MergeReply[] = []
+ for (let i = start; i <= end; i++) {
+ const target = {
+ repoId: 't',
+ account: 'git',
+ repository: 'test',
+ branches: ['main'],
+ }
+ pool.push({
+ target,
+ source: target,
+ commit: '4b825dc642cb6eb9a060e54bf8d69288fbee4904',
+ sequence: i,
+ outcome: { result: i },
+ })
+ }
+ return pool
+}
diff --git a/_import-artifact/git/solidify.ts b/_import-artifact/git/solidify.ts
new file mode 100644
index 000000000000..491685d97dec
--- /dev/null
+++ b/_import-artifact/git/solidify.ts
@@ -0,0 +1,177 @@
+import { assert, Debug, equal } from '@utils'
+import FS from './fs.ts'
+import {
+ isMergeReply,
+ isPierceRequest,
+ isRemoteRequest,
+ isReply,
+ MergeReply,
+ Pending,
+ PID,
+ Pierce,
+ Poolable,
+ Proctype,
+ RemoteRequest,
+ Request,
+ SolidReply,
+ SolidRequest,
+ Solids,
+} from '@/constants.ts'
+import IOChannel from '@io/io-channel.ts'
+
+const log = Debug('AI:git:solidify')
+
+/**
+ * Takes in an unordered collection of operations, and orders them in the
+ * .io.json file, then performs a commit.
+ * The allowed operations are:
+ * - execute: an action to be executed serially on this branch. May be
+ * external or from another branch.
+ * - branch: a new branch is being created with an origin action to be executed.
+ * - merge: an async result is returning, or an external action is being
+ * inserted into the branch.
+ * - reply: a result is being returned from a dispatch after serial execution.
+ */
+export const solidify = async (
+ fs: FS,
+ pool: (Poolable | Pierce)[],
+ reply?: SolidReply,
+ pending?: Pending,
+) => {
+ if (!Array.isArray(pool)) {
+ pool = [pool]
+ }
+ assert(
+ pool.length > 0 || reply || fs.isChanged || pending?.requests.length,
+ 'no-op',
+ )
+ checkPool(pool)
+ assert(!reply || !pending, 'cannot have both reply and pending')
+ const io = await IOChannel.load(fs)
+
+ const branches: number[] = []
+ const poolables: (MergeReply | RemoteRequest)[] = []
+ const parents = []
+ const deletes = []
+
+ if (pending) {
+ assert(pending.requests.length, 'cannot be pending without requests')
+ log('solidifyPool pending', pending)
+ const { commit, requests, sequence } = pending
+ const sequenced = io.addPending(sequence, commit, requests)
+ sequenced.forEach((r) => {
+ if (equal(r.target, fs.pid)) {
+ collectBranch(r, r.sequence, branches)
+ } else {
+ const remoteRequest = { ...r, commit: 'updated post commit' }
+ poolables.push(remoteRequest)
+ }
+ })
+ }
+ let poolPlusReply: (Poolable | Pierce | SolidReply)[] = pool
+ if (reply) {
+ poolPlusReply = [reply, ...pool]
+ }
+ for (const poolable of poolPlusReply) {
+ if (isReply(poolable)) {
+ log('reply', poolable)
+ const request = io.reply(poolable)
+
+ const { outcome } = poolable
+ if (!isPierceRequest(request)) {
+ if (!equal(request.source, fs.pid)) {
+ const target = request.source
+ const source = request.target
+ const sequence = request.sequence
+ const reply: MergeReply = {
+ target,
+ source,
+ sequence,
+ outcome,
+ commit: 'updated post commit',
+ }
+ poolables.push(reply)
+ }
+ }
+ if (isBranch(request, fs.pid)) {
+ assert(isMergeReply(poolable), 'branch requires merge reply')
+ log('branch reply', poolable.commit)
+ parents.push(poolable.commit)
+ if (request.proctype === Proctype.enum.BRANCH) {
+ const { sequence } = poolable
+ const branchPid = io.getBranchPid(sequence)
+ deletes.push({ pid: branchPid, commit: poolable.commit })
+ }
+ }
+ } else {
+ if (isRemoteRequest(poolable)) {
+ parents.push(poolable.commit)
+ }
+ const sequence = io.addRequest(poolable)
+ collectBranch(poolable, sequence, branches)
+ }
+ }
+
+ let exe: Solids['exe']
+ if (io.isExecutionAvailable()) {
+ exe = io.setExecution()
+ }
+
+ if (pool.length || pending || reply) {
+ io.save()
+ }
+ // TODO pass in all the db checks to go with this write
+ // TODO write blobs atomically
+
+ // const duplicateCheck = new Set(parents)
+ // assert(duplicateCheck.size === parents.length, 'duplicate parents')
+
+ const { next, changes, commit } = await fs.writeCommitObject('pool', parents)
+ log('head', commit)
+ for (const poolable of poolables) {
+ poolable.commit = next.oid
+ }
+
+ const solids: Solids = {
+ oid: next.oid,
+ commit,
+ changes,
+ exe,
+ branches,
+ poolables,
+ deletes,
+ }
+ return solids
+}
+
+const checkPool = (pool: (Poolable | Pierce)[]) => {
+ if (!pool.length) {
+ return
+ }
+ const { target } = pool[0]
+ for (const poolable of pool) {
+ if (!equal(poolable.target, target)) {
+ throw new Error('pool has mixed targets')
+ }
+ }
+ // TODO use a hash on poolables to determine uniqueness in the pool
+ return target
+ // TODO a request and a reply with the same id cannot be in the same pool
+}
+const isBranch = (request: SolidRequest | Pierce, thisPid: PID) => {
+ if (!isPierceRequest(request)) {
+ if (!equal(request.target, thisPid)) {
+ return false
+ }
+ }
+ return request.proctype === Proctype.enum.BRANCH ||
+ request.proctype === Proctype.enum.DAEMON
+}
+const collectBranch = (req: Request, sequence: number, branches: number[]) => {
+ const { proctype } = req
+ if (proctype === Proctype.enum.BRANCH || proctype === Proctype.enum.DAEMON) {
+ branches.push(sequence)
+ } else {
+ assert(proctype === Proctype.enum.SERIAL, `invalid proctype: ${proctype}`)
+ }
+}
diff --git a/_import-artifact/guts/__snapshots__/guts-ai-isolates.ts.json b/_import-artifact/guts/__snapshots__/guts-ai-isolates.ts.json
new file mode 100644
index 000000000000..62e114617cb9
--- /dev/null
+++ b/_import-artifact/guts/__snapshots__/guts-ai-isolates.ts.json
@@ -0,0 +1,2012 @@
+{
+ "isolates: files:ls": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382628,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 768,
+ "openAiProcessingMs": 562,
+ "usage": {
+ "completion_tokens": 38,
+ "prompt_tokens": 307,
+ "total_tokens": 345,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382630,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1519,
+ "openAiProcessingMs": 1315,
+ "usage": {
+ "completion_tokens": 73,
+ "prompt_tokens": 397,
+ "total_tokens": 470,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls .",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory (\".\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382632,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1487,
+ "openAiProcessingMs": 1289,
+ "usage": {
+ "completion_tokens": 76,
+ "prompt_tokens": 484,
+ "total_tokens": 560,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls .",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory (\".\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls /",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Q5pWioxFjQIwEuvZ86tihahC",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the root directory.\"],\"path\":\"/\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382634,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1041,
+ "openAiProcessingMs": 822,
+ "usage": {
+ "completion_tokens": 38,
+ "prompt_tokens": 574,
+ "total_tokens": 612,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls .",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory (\".\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls /",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Q5pWioxFjQIwEuvZ86tihahC",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the root directory.\"],\"path\":\"/\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_Q5pWioxFjQIwEuvZ86tihahC"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Here are the files and directories in the root directory (\"/\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382636,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1715,
+ "openAiProcessingMs": 1496,
+ "usage": {
+ "completion_tokens": 76,
+ "prompt_tokens": 664,
+ "total_tokens": 740,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls .",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory (\".\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls /",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Q5pWioxFjQIwEuvZ86tihahC",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the root directory.\"],\"path\":\"/\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_Q5pWioxFjQIwEuvZ86tihahC"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the root directory (\"/\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls --all",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_vaQVVqRGxGLkaYiIffX6Lcfu",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list all files including hidden files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":true}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382639,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1291,
+ "openAiProcessingMs": 1066,
+ "usage": {
+ "completion_tokens": 41,
+ "prompt_tokens": 755,
+ "total_tokens": 796,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls .",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory (\".\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls /",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Q5pWioxFjQIwEuvZ86tihahC",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the root directory.\"],\"path\":\"/\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_Q5pWioxFjQIwEuvZ86tihahC"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the root directory (\"/\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls --all",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_vaQVVqRGxGLkaYiIffX6Lcfu",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list all files including hidden files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":true}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\".gitattributes\",\".gitignore\",\".io.json\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_vaQVVqRGxGLkaYiIffX6Lcfu"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Here are all the files and directories in the current directory (including hidden files):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - .gitattributes\n - .gitignore\n - .io.json\n - LICENSE\n - README.md",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382641,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1765,
+ "openAiProcessingMs": 1567,
+ "usage": {
+ "completion_tokens": 97,
+ "prompt_tokens": 858,
+ "total_tokens": 955,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lHiQmnnw17B1t9V7bgKw6qnS",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_lHiQmnnw17B1t9V7bgKw6qnS"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls .",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the current directory (\".\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls /",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Q5pWioxFjQIwEuvZ86tihahC",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list the files in the root directory.\"],\"path\":\"/\",\"count\":false,\"all\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_Q5pWioxFjQIwEuvZ86tihahC"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are the files and directories in the root directory (\"/\"):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls --all",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_vaQVVqRGxGLkaYiIffX6Lcfu",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user requested to list all files including hidden files in the current directory.\"],\"path\":\".\",\"count\":false,\"all\":true}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\".gitattributes\",\".gitignore\",\".io.json\",\"LICENSE\",\"README.md\",\"tmp\"]",
+ "tool_call_id": "call_vaQVVqRGxGLkaYiIffX6Lcfu"
+ },
+ {
+ "role": "assistant",
+ "content": "Here are all the files and directories in the current directory (including hidden files):\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n - tmp/\n\n- **Files:**\n - .gitattributes\n - .gitignore\n - .io.json\n - LICENSE\n - README.md",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls ./nonexistent",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "The directory `./nonexistent` does not exist. Please check the path and try again.",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382644,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1067,
+ "openAiProcessingMs": 866,
+ "usage": {
+ "completion_tokens": 20,
+ "prompt_tokens": 971,
+ "total_tokens": 991,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "isolates: files:write": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "write \"c\" to the file test.txt",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCX1hzuFugw4yCCyW5yxu334",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"Writing the character 'c' to the file test.txt.\"],\"path\":\"test.txt\",\"content\":\"c\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382646,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1088,
+ "openAiProcessingMs": 866,
+ "usage": {
+ "completion_tokens": 35,
+ "prompt_tokens": 315,
+ "total_tokens": 350,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "write \"c\" to the file test.txt",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCX1hzuFugw4yCCyW5yxu334",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"Writing the character 'c' to the file test.txt.\"],\"path\":\"test.txt\",\"content\":\"c\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":1}",
+ "tool_call_id": "call_SCX1hzuFugw4yCCyW5yxu334"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "The character \"c\" has been successfully written to the file `test.txt`.",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382648,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1068,
+ "openAiProcessingMs": 856,
+ "usage": {
+ "completion_tokens": 17,
+ "prompt_tokens": 368,
+ "total_tokens": 385,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "write \"c\" to the file test.txt",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCX1hzuFugw4yCCyW5yxu334",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"Writing the character 'c' to the file test.txt.\"],\"path\":\"test.txt\",\"content\":\"c\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":1}",
+ "tool_call_id": "call_SCX1hzuFugw4yCCyW5yxu334"
+ },
+ {
+ "role": "assistant",
+ "content": "The character \"c\" has been successfully written to the file `test.txt`.",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_uXPTWZH9tmIXQ0U7yUuAjafu",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"Listing the files in the current directory to see the contents.\"],\"path\":\"\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382649,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 984,
+ "openAiProcessingMs": 779,
+ "usage": {
+ "completion_tokens": 30,
+ "prompt_tokens": 398,
+ "total_tokens": 428,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "write \"c\" to the file test.txt",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCX1hzuFugw4yCCyW5yxu334",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"Writing the character 'c' to the file test.txt.\"],\"path\":\"test.txt\",\"content\":\"c\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":1}",
+ "tool_call_id": "call_SCX1hzuFugw4yCCyW5yxu334"
+ },
+ {
+ "role": "assistant",
+ "content": "The character \"c\" has been successfully written to the file `test.txt`.",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "ls",
+ "role": "user",
+ "name": "test"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_uXPTWZH9tmIXQ0U7yUuAjafu",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"Listing the files in the current directory to see the contents.\"],\"path\":\"\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\",\"test.txt\"]",
+ "tool_call_id": "call_uXPTWZH9tmIXQ0U7yUuAjafu"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "The files in the current directory are as follows:\n\n- agents/\n- curtains/\n- Definitiions/\n- images/\n- info/\n- stucks/\n- templates/\n- tests/\n- threads/\n- LICENSE\n- README.md\n- test.txt\n\nThe `test.txt` file is present in this directory.",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382651,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_e2bde53e6e",
+ "duration": 1623,
+ "openAiProcessingMs": 1417,
+ "usage": {
+ "completion_tokens": 64,
+ "prompt_tokens": 481,
+ "total_tokens": 545,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/guts/__snapshots__/guts-focus.ts.json b/_import-artifact/guts/__snapshots__/guts-focus.ts.json
new file mode 100644
index 000000000000..3181edcac6d1
--- /dev/null
+++ b/_import-artifact/guts/__snapshots__/guts-focus.ts.json
@@ -0,0 +1,8144 @@
+{
+ "focus: thread management": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Hello! How can I assist you today?",
+ "name": "agents/reasoner.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382549,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 949,
+ "openAiProcessingMs": 455,
+ "usage": {
+ "completion_tokens": 10,
+ "prompt_tokens": 2466,
+ "total_tokens": 2476,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": "Hello! How can I assist you today?",
+ "name": "agents_reasoner_md",
+ "refusal": null
+ },
+ {
+ "content": "start a new thread",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_j7FWvhjYdlNxQJri6IpxEfu2",
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382551,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1051,
+ "openAiProcessingMs": 806,
+ "usage": {
+ "completion_tokens": 13,
+ "prompt_tokens": 2506,
+ "total_tokens": 2519,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ }
+ ],
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_T20": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "list the files I have",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lFJO7iVhCCDXMtLtv6sqcaZG",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user asked to list the files they have, which suggests that they want to see the directory contents.\",\"The files_ls tool is capable of listing all the files within a specified directory.\",\"Since no specific directory was mentioned, we can assume they want the list of files in the current directory. Using the default path for files_ls, which is \\\".\\\", should provide the necessary information.\"],\"path\":\".\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382554,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 2002,
+ "openAiProcessingMs": 1788,
+ "usage": {
+ "completion_tokens": 95,
+ "prompt_tokens": 2470,
+ "total_tokens": 2565,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "list the files I have",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_lFJO7iVhCCDXMtLtv6sqcaZG",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user asked to list the files they have, which suggests that they want to see the directory contents.\",\"The files_ls tool is capable of listing all the files within a specified directory.\",\"Since no specific directory was mentioned, we can assume they want the list of files in the current directory. Using the default path for files_ls, which is \\\".\\\", should provide the necessary information.\"],\"path\":\".\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\"]",
+ "tool_call_id": "call_lFJO7iVhCCDXMtLtv6sqcaZG"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Here's a list of the files and directories you have:\n\n- `agents/`\n- `curtains/`\n- `Definitiions/`\n- `images/`\n- `info/`\n- `stucks/`\n- `templates/`\n- `tests/`\n- `threads/`\n- `LICENSE`\n- `README.md`\n\nThese are the directories and files located in the current directory. Let me know if you need further details or actions performed on any of these files or directories!",
+ "name": "agents/reasoner.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382556,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1930,
+ "openAiProcessingMs": 1708,
+ "usage": {
+ "completion_tokens": 102,
+ "prompt_tokens": 2616,
+ "total_tokens": 2718,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "focus: update from github": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Update the HAL repo to the latest version by using the system agent as an administrative action",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_k1acDvQZkjImD4SFsISJAyBl",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"I need to check the current directory structure to see if there is a directory for the HAL repo.\",\"Listing the files will help identify where the HAL repository is located.\",\"This will guide the next steps for fetching the latest updates for the repo.\"],\"path\":\".\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382559,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1479,
+ "openAiProcessingMs": 959,
+ "usage": {
+ "completion_tokens": 66,
+ "prompt_tokens": 2482,
+ "total_tokens": 2548,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Update the HAL repo to the latest version by using the system agent as an administrative action",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_k1acDvQZkjImD4SFsISJAyBl",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"I need to check the current directory structure to see if there is a directory for the HAL repo.\",\"Listing the files will help identify where the HAL repository is located.\",\"This will guide the next steps for fetching the latest updates for the repo.\"],\"path\":\".\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\"]",
+ "tool_call_id": "call_k1acDvQZkjImD4SFsISJAyBl"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_BGfBk775ebJY0zXMQGDBJ2jd",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"To manage the HAL repository, I need to browse into its directory.\",\"The next step is to list files within the 'agents' directory where it is likely located.\",\"This will help confirm the presence and the current state of the HAL repository.\"],\"path\":\"agents\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382561,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1423,
+ "openAiProcessingMs": 930,
+ "usage": {
+ "completion_tokens": 66,
+ "prompt_tokens": 2599,
+ "total_tokens": 2665,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Update the HAL repo to the latest version by using the system agent as an administrative action",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_k1acDvQZkjImD4SFsISJAyBl",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"I need to check the current directory structure to see if there is a directory for the HAL repo.\",\"Listing the files will help identify where the HAL repository is located.\",\"This will guide the next steps for fetching the latest updates for the repo.\"],\"path\":\".\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\"]",
+ "tool_call_id": "call_k1acDvQZkjImD4SFsISJAyBl"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_BGfBk775ebJY0zXMQGDBJ2jd",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"To manage the HAL repository, I need to browse into its directory.\",\"The next step is to list files within the 'agents' directory where it is likely located.\",\"This will help confirm the presence and the current state of the HAL repository.\"],\"path\":\"agents\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agent-fixture.md\",\"cheeky-bstrd.md\",\"create-agent.md\",\"creatorBot.md\",\"dave-prompt-extractor.md\",\"dreamcatcher.md\",\"dumb-bot.md\",\"example-drone.md\",\"files.md\",\"gpt-4o-mini.md\",\"gpt-4o.md\",\"hal2.md\",\"hal3.md\",\"hamr.md\",\"imogen.md\",\"login-github.md\",\"meetings.md\",\"merger.md\",\"o1-mini.md\",\"o1.md\",\"reasoner.md\",\"remappings.md\",\"router.md\",\"stuck-loop.md\",\"switchboard.md\",\"system.md\",\"test_gen.md\",\"test-assessor.md\",\"test-file-runner.md\",\"test-requester.md\",\"test-results-summary.md\",\"topic.md\"]",
+ "tool_call_id": "call_BGfBk775ebJY0zXMQGDBJ2jd"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "arguments": "{\"reasoning\":[\"The user wants to update the HAL repository to the latest version using the system agent.\",\"I am not sure which version of the HAL repository we are supposed to update or how the update process should be undertaken.\",\"Given there are files named 'hal2.md' and 'hal3.md' in the agents directory, I need gpt-4o's insight on which version we should focus on and the best approach to update the repository.\",\"This is to avoid making wrong assumptions and to execute the update process correctly.\"],\"content\":\"How should I update the HOL repository to the latest version when there are multiple \\\"hal\\\" files such as hal2.md and hal3.md present in the agents directory? Which file or version should I consider for updating, and what steps should I follow for a successful update using the system agent?\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382563,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 2892,
+ "openAiProcessingMs": 2652,
+ "usage": {
+ "completion_tokens": 181,
+ "prompt_tokens": 2831,
+ "total_tokens": 3012,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1920
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Update the HAL repo to the latest version by using the system agent as an administrative action",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_k1acDvQZkjImD4SFsISJAyBl",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"I need to check the current directory structure to see if there is a directory for the HAL repo.\",\"Listing the files will help identify where the HAL repository is located.\",\"This will guide the next steps for fetching the latest updates for the repo.\"],\"path\":\".\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\"]",
+ "tool_call_id": "call_k1acDvQZkjImD4SFsISJAyBl"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_BGfBk775ebJY0zXMQGDBJ2jd",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"To manage the HAL repository, I need to browse into its directory.\",\"The next step is to list files within the 'agents' directory where it is likely located.\",\"This will help confirm the presence and the current state of the HAL repository.\"],\"path\":\"agents\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agent-fixture.md\",\"cheeky-bstrd.md\",\"create-agent.md\",\"creatorBot.md\",\"dave-prompt-extractor.md\",\"dreamcatcher.md\",\"dumb-bot.md\",\"example-drone.md\",\"files.md\",\"gpt-4o-mini.md\",\"gpt-4o.md\",\"hal2.md\",\"hal3.md\",\"hamr.md\",\"imogen.md\",\"login-github.md\",\"meetings.md\",\"merger.md\",\"o1-mini.md\",\"o1.md\",\"reasoner.md\",\"remappings.md\",\"router.md\",\"stuck-loop.md\",\"switchboard.md\",\"system.md\",\"test_gen.md\",\"test-assessor.md\",\"test-file-runner.md\",\"test-requester.md\",\"test-results-summary.md\",\"topic.md\"]",
+ "tool_call_id": "call_BGfBk775ebJY0zXMQGDBJ2jd"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "arguments": "{\"reasoning\":[\"The user wants to update the HAL repository to the latest version using the system agent.\",\"I am not sure which version of the HAL repository we are supposed to update or how the update process should be undertaken.\",\"Given there are files named 'hal2.md' and 'hal3.md' in the agents directory, I need gpt-4o's insight on which version we should focus on and the best approach to update the repository.\",\"This is to avoid making wrong assumptions and to execute the update process correctly.\"],\"content\":\"How should I update the HOL repository to the latest version when there are multiple \\\"hal\\\" files such as hal2.md and hal3.md present in the agents directory? Which file or version should I consider for updating, and what steps should I follow for a successful update using the system agent?\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "To update the HOL (Higher Order Logic) repository to the latest version when there are multiple \"hal\" files, such as `hal2.md` and `hal3.md`, you need to consider the following steps:\n\n1. **Understand the Purpose of HAL Files**: \n - HAL files typically serve as documentation or configuration that dictate the behavior of the agents. It's crucial to understand what each file (like `hal2.md` and `hal3.md`) represents. They might be different versions or configurations.\n - Check if there are version logs, comments, or documentation within the repository or files themselves that explain the differences.\n\n2. **Determine the Latest or Appropriate Version**:\n - Check repository documentation, commit messages, or version logs to determine which HAL file is the most recent or appropriate based on your specific requirements.\n - If there is a versioning system in place, the latest file may be indicated by a higher number or a specific tag.\n\n3. **Backup Current State**:\n - It's important to backup the current state of your repository and configuration before making any changes. This includes all HAL files and any configuration or settings related to the system agent.\n\n4. **Update the Repository**:\n - Pull the latest version of the repository using a version control command like `git pull` if you're using Git.\n - Ensure that your local environment is synchronized with the remote repository.\n\n5. **Select the HAL File for the Update**:\n - Once you've determined the appropriate file (for example, `hal3.md` if it's the latest), ensure that it is correctly placed or configured to be used by the system agent.\n - You may need to update configuration settings in the agent to point to the correct HAL file or merge necessary parts from multiple files.\n\n6. **Test the Configuration**:\n - After making changes, thoroughly test to ensure that the system agent works as expected with the selected HAL file. This might involve running predefined test cases or using a test environment.\n - Look out for errors or issues that might arise due to differences in configurations between the HAL files.\n\n7. **Documentation and Rollout**:\n - Update the documentation to reflect the changes made and the rationale behind choosing the specific HAL file.\n - If the update is successful, and you’re satisfied with the changes, proceed with rolling out the update to production environments, ensuring that any relevant team members are informed of the changes.\n\nBy following these steps, you should be able to successfully update your HOL repository with the appropriate configuration while minimizing errors and ensuring a smooth transition.",
+ "tool_call_id": "call_TrqXpjurgn77TXzAtjLUw3lF"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "I gathered insights into the HAL files present in the agents directory. To proceed with updating the HOL repository using the system agent, you will need to consider which version of the \"hal\" files (e.g., `hal2.md` or `hal3.md`) should be prioritized for the update. \n\nThe reasoning process suggests the following steps:\n1. **Identify the Purpose:** Understand what each HAL file (such as `hal2` and `hal3`) represents—whether they are different versions or configurations.\n2. **Determine the Appropriate Version:** Check the repository's documentation or logs for information on which HAL file is the latest or most appropriate.\n3. **Backup Current State:** Safeguard the current state of the repository and configuration.\n4. **Update Your Environment:** Synchronize your local environment with the remote repository.\n5. **Choose the Right HAL File:** Ensure the system agent uses the correct HAL file and adjust any configurations necessary.\n6. **Test:** Perform thorough testing to ensure the system agent works as expected with the chosen HAL file.\n7. **Document and Rollout:** Update documentation, ensure team members are informed, and implement the update if successful.\n\nIf you need to proceed with any specific tasks such as accessing or updating files, or if there are additional instructions based on the agent-specific methodology for updating, please let me know!",
+ "name": "agents/reasoner.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382573,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 4131,
+ "openAiProcessingMs": 3890,
+ "usage": {
+ "completion_tokens": 274,
+ "prompt_tokens": 3549,
+ "total_tokens": 3823,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2176
+ }
+ }
+ }
+ }
+ }
+ ],
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q/napp-gpt-4o-10": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "messages": [
+ {
+ "content": "How should I update the HOL repository to the latest version when there are multiple \"hal\" files such as hal2.md and hal3.md present in the agents directory? Which file or version should I consider for updating, and what steps should I follow for a successful update using the system agent?",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "Your name is gpt-4o, or 4o for short.",
+ "role": "system",
+ "name": "agents_gpt-4o_md"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "To update the HOL (Higher Order Logic) repository to the latest version when there are multiple \"hal\" files, such as `hal2.md` and `hal3.md`, you need to consider the following steps:\n\n1. **Understand the Purpose of HAL Files**: \n - HAL files typically serve as documentation or configuration that dictate the behavior of the agents. It's crucial to understand what each file (like `hal2.md` and `hal3.md`) represents. They might be different versions or configurations.\n - Check if there are version logs, comments, or documentation within the repository or files themselves that explain the differences.\n\n2. **Determine the Latest or Appropriate Version**:\n - Check repository documentation, commit messages, or version logs to determine which HAL file is the most recent or appropriate based on your specific requirements.\n - If there is a versioning system in place, the latest file may be indicated by a higher number or a specific tag.\n\n3. **Backup Current State**:\n - It's important to backup the current state of your repository and configuration before making any changes. This includes all HAL files and any configuration or settings related to the system agent.\n\n4. **Update the Repository**:\n - Pull the latest version of the repository using a version control command like `git pull` if you're using Git.\n - Ensure that your local environment is synchronized with the remote repository.\n\n5. **Select the HAL File for the Update**:\n - Once you've determined the appropriate file (for example, `hal3.md` if it's the latest), ensure that it is correctly placed or configured to be used by the system agent.\n - You may need to update configuration settings in the agent to point to the correct HAL file or merge necessary parts from multiple files.\n\n6. **Test the Configuration**:\n - After making changes, thoroughly test to ensure that the system agent works as expected with the selected HAL file. This might involve running predefined test cases or using a test environment.\n - Look out for errors or issues that might arise due to differences in configurations between the HAL files.\n\n7. **Documentation and Rollout**:\n - Update the documentation to reflect the changes made and the rationale behind choosing the specific HAL file.\n - If the update is successful, and you’re satisfied with the changes, proceed with rolling out the update to production environments, ensuring that any relevant team members are informed of the changes.\n\nBy following these steps, you should be able to successfully update your HOL repository with the appropriate configuration while minimizing errors and ensuring a smooth transition.",
+ "name": "agents/gpt-4o.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382567,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_a7d06e42a7",
+ "duration": 5033,
+ "openAiProcessingMs": 4832,
+ "usage": {
+ "completion_tokens": 521,
+ "prompt_tokens": 108,
+ "total_tokens": 629,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "focus: infinite loop regression": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Write a file with the following text \"I love to be in Paris in the Spring\". Then save it as paris.txt. Then replace all text in that file where \"Paris\" occurs with \"Edinburgh\". Then rename the file Edinburgh.txt",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_UkeTB2ekFfwVXeSR8BR3s46c",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"I need to write a file with the specified content.\",\"The desired content to write in the file is 'I love to be in Paris in the Spring'.\",\"The file is to be named 'paris.txt'.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Paris in the Spring\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382578,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1863,
+ "openAiProcessingMs": 1345,
+ "usage": {
+ "completion_tokens": 76,
+ "prompt_tokens": 2513,
+ "total_tokens": 2589,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Write a file with the following text \"I love to be in Paris in the Spring\". Then save it as paris.txt. Then replace all text in that file where \"Paris\" occurs with \"Edinburgh\". Then rename the file Edinburgh.txt",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_UkeTB2ekFfwVXeSR8BR3s46c",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"I need to write a file with the specified content.\",\"The desired content to write in the file is 'I love to be in Paris in the Spring'.\",\"The file is to be named 'paris.txt'.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Paris in the Spring\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":35}",
+ "tool_call_id": "call_UkeTB2ekFfwVXeSR8BR3s46c"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Hkt2sxaKZwp3GSt231P2qlF7",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the file 'paris.txt' to find and replace all instances of 'Paris' with 'Edinburgh'.\",\"After reading the content, I'll modify it accordingly.\"],\"path\":\"paris.txt\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382581,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1549,
+ "openAiProcessingMs": 1061,
+ "usage": {
+ "completion_tokens": 60,
+ "prompt_tokens": 2608,
+ "total_tokens": 2668,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Write a file with the following text \"I love to be in Paris in the Spring\". Then save it as paris.txt. Then replace all text in that file where \"Paris\" occurs with \"Edinburgh\". Then rename the file Edinburgh.txt",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_UkeTB2ekFfwVXeSR8BR3s46c",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"I need to write a file with the specified content.\",\"The desired content to write in the file is 'I love to be in Paris in the Spring'.\",\"The file is to be named 'paris.txt'.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Paris in the Spring\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":35}",
+ "tool_call_id": "call_UkeTB2ekFfwVXeSR8BR3s46c"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Hkt2sxaKZwp3GSt231P2qlF7",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the file 'paris.txt' to find and replace all instances of 'Paris' with 'Edinburgh'.\",\"After reading the content, I'll modify it accordingly.\"],\"path\":\"paris.txt\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "I love to be in Paris in the Spring",
+ "tool_call_id": "call_Hkt2sxaKZwp3GSt231P2qlF7"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_cRcnTMu4Y0GMv2FtlASGaa5H",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"After reading the content of 'paris.txt', I will replace 'Paris' with 'Edinburgh' in the text.\",\"The modified text will then be written back to the file, replacing the old content.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Edinburgh in the Spring\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382583,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1675,
+ "openAiProcessingMs": 1462,
+ "usage": {
+ "completion_tokens": 74,
+ "prompt_tokens": 2690,
+ "total_tokens": 2764,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1920
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Write a file with the following text \"I love to be in Paris in the Spring\". Then save it as paris.txt. Then replace all text in that file where \"Paris\" occurs with \"Edinburgh\". Then rename the file Edinburgh.txt",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_UkeTB2ekFfwVXeSR8BR3s46c",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"I need to write a file with the specified content.\",\"The desired content to write in the file is 'I love to be in Paris in the Spring'.\",\"The file is to be named 'paris.txt'.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Paris in the Spring\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":35}",
+ "tool_call_id": "call_UkeTB2ekFfwVXeSR8BR3s46c"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Hkt2sxaKZwp3GSt231P2qlF7",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the file 'paris.txt' to find and replace all instances of 'Paris' with 'Edinburgh'.\",\"After reading the content, I'll modify it accordingly.\"],\"path\":\"paris.txt\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "I love to be in Paris in the Spring",
+ "tool_call_id": "call_Hkt2sxaKZwp3GSt231P2qlF7"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_cRcnTMu4Y0GMv2FtlASGaa5H",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"After reading the content of 'paris.txt', I will replace 'Paris' with 'Edinburgh' in the text.\",\"The modified text will then be written back to the file, replacing the old content.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Edinburgh in the Spring\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":39}",
+ "tool_call_id": "call_cRcnTMu4Y0GMv2FtlASGaa5H"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_pklki7uYxadD9DXy0ASNloJN",
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "arguments": "{\"reasoning\":[\"Having replaced 'Paris' with 'Edinburgh' in 'paris.txt', the final step is to rename the file to 'Edinburgh.txt'.\",\"This will complete the task as described by the user.\"],\"from\":\"paris.txt\",\"to\":\"Edinburgh.txt\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382586,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1515,
+ "openAiProcessingMs": 1061,
+ "usage": {
+ "completion_tokens": 68,
+ "prompt_tokens": 2783,
+ "total_tokens": 2851,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2048
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "Write a file with the following text \"I love to be in Paris in the Spring\". Then save it as paris.txt. Then replace all text in that file where \"Paris\" occurs with \"Edinburgh\". Then rename the file Edinburgh.txt",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_UkeTB2ekFfwVXeSR8BR3s46c",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"I need to write a file with the specified content.\",\"The desired content to write in the file is 'I love to be in Paris in the Spring'.\",\"The file is to be named 'paris.txt'.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Paris in the Spring\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":35}",
+ "tool_call_id": "call_UkeTB2ekFfwVXeSR8BR3s46c"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_Hkt2sxaKZwp3GSt231P2qlF7",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the file 'paris.txt' to find and replace all instances of 'Paris' with 'Edinburgh'.\",\"After reading the content, I'll modify it accordingly.\"],\"path\":\"paris.txt\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "I love to be in Paris in the Spring",
+ "tool_call_id": "call_Hkt2sxaKZwp3GSt231P2qlF7"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_cRcnTMu4Y0GMv2FtlASGaa5H",
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "arguments": "{\"reasoning\":[\"After reading the content of 'paris.txt', I will replace 'Paris' with 'Edinburgh' in the text.\",\"The modified text will then be written back to the file, replacing the old content.\"],\"path\":\"paris.txt\",\"content\":\"I love to be in Edinburgh in the Spring\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"charactersWritten\":39}",
+ "tool_call_id": "call_cRcnTMu4Y0GMv2FtlASGaa5H"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_pklki7uYxadD9DXy0ASNloJN",
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "arguments": "{\"reasoning\":[\"Having replaced 'Paris' with 'Edinburgh' in 'paris.txt', the final step is to rename the file to 'Edinburgh.txt'.\",\"This will complete the task as described by the user.\"],\"from\":\"paris.txt\",\"to\":\"Edinburgh.txt\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "",
+ "tool_call_id": "call_pklki7uYxadD9DXy0ASNloJN"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "I have successfully completed the task you described:\n\n1. Created a file named `paris.txt` with the content: \"I love to be in Paris in the Spring\".\n2. Replaced \"Paris\" with \"Edinburgh\" in the file content.\n3. Renamed the file from `paris.txt` to `Edinburgh.txt`.\n\nIf you need any more assistance or have further instructions, feel free to let me know!",
+ "name": "agents/reasoner.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382588,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1816,
+ "openAiProcessingMs": 1342,
+ "usage": {
+ "completion_tokens": 89,
+ "prompt_tokens": 2864,
+ "total_tokens": 2953,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2048
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/guts/__snapshots__/guts-longthread.ts.json b/_import-artifact/guts/__snapshots__/guts-longthread.ts.json
new file mode 100644
index 000000000000..2527c126b4f3
--- /dev/null
+++ b/_import-artifact/guts/__snapshots__/guts-longthread.ts.json
@@ -0,0 +1,371 @@
+{
+ "longthread: basic": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "say \"Hello\"",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Hello!",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382538,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 577,
+ "openAiProcessingMs": 339,
+ "usage": {
+ "completion_tokens": 3,
+ "prompt_tokens": 85,
+ "total_tokens": 88,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "longthread: chat": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "say the word: \"hello\" verbatim without calling any functions",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "hello",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382540,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 401,
+ "openAiProcessingMs": 187,
+ "usage": {
+ "completion_tokens": 2,
+ "prompt_tokens": 94,
+ "total_tokens": 96,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "say the word: \"hello\" verbatim without calling any functions",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "role": "assistant",
+ "content": "hello",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "what is your name ?",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Assistant.",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382541,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 391,
+ "openAiProcessingMs": 183,
+ "usage": {
+ "completion_tokens": 3,
+ "prompt_tokens": 116,
+ "total_tokens": 119,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "say the word: \"hello\" verbatim without calling any functions",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "role": "assistant",
+ "content": "hello",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "what is your name ?",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "role": "assistant",
+ "content": "Assistant.",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "repeat your last, without calling any functions",
+ "role": "user",
+ "name": "ai"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Assistant.",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382542,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 467,
+ "openAiProcessingMs": 257,
+ "usage": {
+ "completion_tokens": 3,
+ "prompt_tokens": 142,
+ "total_tokens": 145,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/guts/__snapshots__/guts-tps-reports.ts.json b/_import-artifact/guts/__snapshots__/guts-tps-reports.ts.json
new file mode 100644
index 000000000000..4a4bb9dbaf48
--- /dev/null
+++ b/_import-artifact/guts/__snapshots__/guts-tps-reports.ts.json
@@ -0,0 +1,1890 @@
+{
+ "tps: run fixture test": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "run test ./tests/test-fixture.test.md",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_KGMa7arG8TQIqqv1fqTDqdqB",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the specified test file to understand what tests are described in it.\",\"Running a test typically involves reading the test file, understanding the setup and assertions, and then executing the test logic.\",\"Before proceeding to execute or simulate the tests, I should gather the required details from the file itself.\"],\"path\":\"./tests/test-fixture.test.md\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382600,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1680,
+ "openAiProcessingMs": 1170,
+ "usage": {
+ "completion_tokens": 87,
+ "prompt_tokens": 2474,
+ "total_tokens": 2561,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "run test ./tests/test-fixture.test.md",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_KGMa7arG8TQIqqv1fqTDqdqB",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the specified test file to understand what tests are described in it.\",\"Running a test typically involves reading the test file, understanding the setup and assertions, and then executing the test logic.\",\"Before proceeding to execute or simulate the tests, I should gather the required details from the file itself.\"],\"path\":\"./tests/test-fixture.test.md\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "---\ntarget: agents/agent-fixture.md\nassessor: agents/test-assessor.md\n---\n\n## Call the local function\n\n**Prompts**\n\n- Call the local function\n\n**Expectations**\n\n- local function was called once\n- result was \"local reply\"\n\n## Fail a test\n\n**Prompts**\n\n- Call the local function\n\n**Expectations**\n\n- result was \"this expectation should fail\"\n\n## Throw an error\n\n**Prompts**\n\n- Call the error function\n\n**Expectations**\n\n- an error was thrown\n\n## Dependencies function\n\n**Dependencies**\n\n- Call the local function\n\n**Prompts**\n\n- say hello\n\n**Expectations**\n\n- hello was responded to\n- local function was called once\n\n## Multiple Dependencies\n\n**Dependencies**\n\n- Dependencies function\n- Call the local function\n\n**Prompts**\n\n- say goodbye\n\n**Expectations**\n\n- goodbye was responded to\n- local function was called twice\n- in between the two function calls, a \"hello\" was issued by the user\n",
+ "tool_call_id": "call_KGMa7arG8TQIqqv1fqTDqdqB"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/reasoner.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_rcXdAKhP2tt3r5UvqwxOM0X3",
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "arguments": "{\"reasoning\":[\"The file content indicates that there are multiple tests described, each with specific prompts and expectations.\",\"Understanding the logic behind these tests is crucial, particularly from a coding and test running standpoint.\",\"Analyzing the content to determine how these tests interrelate and should be executed will inform the steps needed to run the test suite effectively.\"],\"content\":\"We have a test file with several test cases defined. The tests include calling a local function, failing a test, throwing an error, testing dependencies, and handling multiple dependencies. \\n\\nThe tests are structured with prompts and expectations:\\n\\n1. **Call the local function**\\n - Expectations: The local function is called once and returns \\\"local reply\\\".\\n\\n2. **Fail a test**\\n - Expectations: The result should be \\\"this expectation should fail\\\".\\n\\n3. **Throw an error**\\n - Expectations: An error is thrown when the error function is invoked.\\n\\n4. **Dependencies function**\\n - Dependencies: This involves calling the local function.\\n - Expectations: A \\\"hello\\\" response should be given after a local function call.\\n\\n5. **Multiple Dependencies**\\n - Dependencies include: the Dependencies function and calling the local function.\\n - Expectations: A \\\"goodbye\\\" response should be given after two calls to the local function, with a \\\"hello\\\" in between.\\n\\nGiven this data, how should we best approach running these tests? What considerations should we have in terms of order of execution and dependencies, and how to ensure all expectations are met accurately?\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729382602,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 4655,
+ "openAiProcessingMs": 4419,
+ "usage": {
+ "completion_tokens": 343,
+ "prompt_tokens": 2779,
+ "total_tokens": 3122,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1792
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "run test ./tests/test-fixture.test.md",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_KGMa7arG8TQIqqv1fqTDqdqB",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"I need to read the content of the specified test file to understand what tests are described in it.\",\"Running a test typically involves reading the test file, understanding the setup and assertions, and then executing the test logic.\",\"Before proceeding to execute or simulate the tests, I should gather the required details from the file itself.\"],\"path\":\"./tests/test-fixture.test.md\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "---\ntarget: agents/agent-fixture.md\nassessor: agents/test-assessor.md\n---\n\n## Call the local function\n\n**Prompts**\n\n- Call the local function\n\n**Expectations**\n\n- local function was called once\n- result was \"local reply\"\n\n## Fail a test\n\n**Prompts**\n\n- Call the local function\n\n**Expectations**\n\n- result was \"this expectation should fail\"\n\n## Throw an error\n\n**Prompts**\n\n- Call the error function\n\n**Expectations**\n\n- an error was thrown\n\n## Dependencies function\n\n**Dependencies**\n\n- Call the local function\n\n**Prompts**\n\n- say hello\n\n**Expectations**\n\n- hello was responded to\n- local function was called once\n\n## Multiple Dependencies\n\n**Dependencies**\n\n- Dependencies function\n- Call the local function\n\n**Prompts**\n\n- say goodbye\n\n**Expectations**\n\n- goodbye was responded to\n- local function was called twice\n- in between the two function calls, a \"hello\" was issued by the user\n",
+ "tool_call_id": "call_KGMa7arG8TQIqqv1fqTDqdqB"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_reasoner_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_rcXdAKhP2tt3r5UvqwxOM0X3",
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "arguments": "{\"reasoning\":[\"The file content indicates that there are multiple tests described, each with specific prompts and expectations.\",\"Understanding the logic behind these tests is crucial, particularly from a coding and test running standpoint.\",\"Analyzing the content to determine how these tests interrelate and should be executed will inform the steps needed to run the test suite effectively.\"],\"content\":\"We have a test file with several test cases defined. The tests include calling a local function, failing a test, throwing an error, testing dependencies, and handling multiple dependencies. \\n\\nThe tests are structured with prompts and expectations:\\n\\n1. **Call the local function**\\n - Expectations: The local function is called once and returns \\\"local reply\\\".\\n\\n2. **Fail a test**\\n - Expectations: The result should be \\\"this expectation should fail\\\".\\n\\n3. **Throw an error**\\n - Expectations: An error is thrown when the error function is invoked.\\n\\n4. **Dependencies function**\\n - Dependencies: This involves calling the local function.\\n - Expectations: A \\\"hello\\\" response should be given after a local function call.\\n\\n5. **Multiple Dependencies**\\n - Dependencies include: the Dependencies function and calling the local function.\\n - Expectations: A \\\"goodbye\\\" response should be given after two calls to the local function, with a \\\"hello\\\" in between.\\n\\nGiven this data, how should we best approach running these tests? What considerations should we have in terms of order of execution and dependencies, and how to ensure all expectations are met accurately?\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "To effectively run your test suite and ensure that all expectations are met accurately, it's essential to consider the structure, dependencies, and order of execution of each test case. Below is a comprehensive approach to handling your tests:\n\n### 1. **Understand the Test Structure and Dependencies**\n\nFirst, let's summarize the tests and their dependencies:\n\n1. **Call the Local Function**\n - **Expectation:** The local function is called once and returns `\"local reply\"`.\n - **Dependencies:** None.\n\n2. **Fail a Test**\n - **Expectation:** The result should be `\"this expectation should fail\"`.\n - **Dependencies:** None.\n\n3. **Throw an Error**\n - **Expectation:** An error is thrown when the error function is invoked.\n - **Dependencies:** None.\n\n4. **Dependencies Function**\n - **Dependencies:** Calls the **Call the Local Function**.\n - **Expectation:** A `\"hello\"` response should be given after a local function call.\n\n5. **Multiple Dependencies**\n - **Dependencies:** \n - **Dependencies Function** (which in turn depends on **Call the Local Function**)\n - Calls the **Call the Local Function** again.\n - **Expectation:** A `\"goodbye\"` response should be given after two calls to the local function, with a `\"hello\"` in between.\n\n### 2. **Determine the Order of Execution**\n\nGiven the dependencies, it's crucial to execute the tests in an order that respects these relationships to avoid failures due to unmet dependencies. Here's a recommended order:\n\n1. **Call the Local Function**\n2. **Dependencies Function**\n3. **Multiple Dependencies**\n4. **Throw an Error**\n5. **Fail a Test**\n\n**Rationale:**\n\n- **Call the Local Function** should run first as it serves as a foundational test that other tests depend on.\n- **Dependencies Function** relies on the local function, so it should execute after the local function test.\n- **Multiple Dependencies** depends on both the Dependencies Function and another call to the local function, so it naturally follows.\n- **Throw an Error** and **Fail a Test** are independent of the others and can run afterward. Running them last ensures that their failure or exception handling doesn't interfere with the dependent tests.\n\n### 3. **Isolate Tests to Prevent Side Effects**\n\nTo ensure that each test runs in a controlled environment without unintended interactions:\n\n- **Use Setup and Teardown Methods:**\n - **Setup:** Initialize the necessary environment before each test. For example, mock functions or reset states.\n - **Teardown:** Clean up after each test to ensure that no residual data affects subsequent tests.\n\n- **Mock Dependencies:**\n - For tests that depend on functions like the local function, use mocking frameworks (e.g., Jest mocks) to simulate their behavior. This ensures that tests remain isolated and predictable.\n\n### 4. **Handle Assertions Accurately**\n\nEnsure that each test accurately verifies its expectations:\n\n1. **Call the Local Function**\n - **Assertion:** Verify that the local function is called exactly once.\n - **Return Value Assertion:** Confirm that it returns `\"local reply\"`.\n\n2. **Fail a Test**\n - **Assertion:** Intentionally set the expected result to `\"this expectation should fail\"`, which contradicts the actual outcome to simulate a failure scenario.\n\n3. **Throw an Error**\n - **Assertion:** Use assertion methods that expect an error to be thrown (e.g., `toThrow` in Jest).\n\n4. **Dependencies Function**\n - **Assertion:** After the local function call, verify that the response is `\"hello\"`.\n\n5. **Multiple Dependencies**\n - **Assertion:** Ensure that after two calls to the local function, with a `\"hello\"` in between, the final response is `\"goodbye\"`.\n\n### 5. **Leverage Testing Framework Features**\n\nUtilize features provided by modern testing frameworks to enhance your test suite:\n\n- **Test Suites and Grouping:**\n - Organize related tests into suites or groups to improve readability and maintainability.\n\n- **BeforeAll and AfterAll Hooks:**\n - For setup and teardown processes that are common across multiple tests.\n\n- **Parameterized Tests:**\n - If applicable, use parameterized tests to run the same test logic with different inputs.\n\n### 6. **Continuous Integration and Automated Testing**\n\nIntegrate your test suite into a CI/CD pipeline to ensure that tests run automatically with each code change, maintaining code quality and catching issues early.\n\n### 7. **Example Implementation Using Jest**\n\nHere's a conceptual example using Jest, a popular JavaScript testing framework:\n\n```javascript\n// localModule.js\nexport const localFunction = () => \"local reply\";\n\nexport const dependenciesFunction = () => {\n const reply = localFunction();\n return \"hello\";\n};\n\nexport const multipleDependenciesFunction = () => {\n const firstReply = localFunction();\n const secondReply = dependenciesFunction();\n const finalReply = localFunction();\n return \"goodbye\";\n};\n\nexport const errorFunction = () => {\n throw new Error(\"Intentional Error\");\n};\n```\n\n```javascript\n// localModule.test.js\nimport {\n localFunction,\n dependenciesFunction,\n multipleDependenciesFunction,\n errorFunction\n} from './localModule';\n\ndescribe('Local Module Tests', () => {\n\n beforeEach(() => {\n // Reset mocks or any state if necessary\n });\n\n test('Call the local function', () => {\n const reply = localFunction();\n expect(reply).toBe(\"local reply\");\n // If using spies to check call count:\n // const spy = jest.spyOn(module, 'localFunction');\n // expect(spy).toHaveBeenCalledTimes(1);\n });\n\n test('Dependencies function', () => {\n const reply = dependenciesFunction();\n expect(reply).toBe(\"hello\");\n });\n\n test('Multiple Dependencies', () => {\n const reply = multipleDependenciesFunction();\n expect(reply).toBe(\"goodbye\");\n });\n\n test('Throw an error', () => {\n expect(() => errorFunction()).toThrow(\"Intentional Error\");\n });\n\n test('Fail a test', () => {\n const result = \"some actual result\";\n expect(result).toBe(\"this expectation should fail\");\n });\n\n});\n```\n\n**Notes:**\n\n- **Spies and Mocks:** To assert that `localFunction` is called a specific number of times, you can use Jest's `jest.spyOn` or `jest.mock` features.\n \n ```javascript\n test('Call the local function once', () => {\n const spy = jest.spyOn(localModule, 'localFunction');\n const reply = localFunction();\n expect(spy).toHaveBeenCalledTimes(1);\n expect(reply).toBe(\"local reply\");\n spy.mockRestore();\n });\n ```\n\n- **Test Order:** Jest runs tests in the order they are defined within a `describe` block. Ensure that dependent tests are placed after their dependencies.\n\n- **Failing Tests:** Intentionally failing a test can be useful to ensure your test suite correctly identifies failures, but remember to update or remove such tests once they've served their purpose to avoid false negatives in your CI pipeline.\n\n### 8. **Best Practices Summary**\n\n- **Respect Dependencies:** Structure your tests to run dependent tests after their dependencies have been validated.\n- **Isolate Tests:** Ensure that tests do not interfere with each other by sharing state or side effects.\n- **Use Mocks and Spies:** Leverage mocking to simulate dependencies and verify interactions.\n- **Clear Assertions:** Make sure each test clearly and accurately asserts its expected outcome.\n- **Maintain Order:** While tests should ideally be independent, when dependencies exist, carefully manage the order of execution.\n- **Automate and Integrate:** Use CI/CD pipelines to run tests automatically and maintain code quality.\n\nBy following this structured approach, you can ensure that your test suite is robust, reliable, and maintains high code quality standards.",
+ "tool_call_id": "call_rcXdAKhP2tt3r5UvqwxOM0X3"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "To execute the test cases, you will need a suitable environment to simulate running these tests, such as using a JavaScript testing framework like Jest. Here’s a conceptual breakdown of how you can implement this with Jest:\n\n1. **Setup Your Test Environment**: Ensure you have Jest installed, and you're familiar with basic test case writing in it.\n\n2. **Implement the Functions for Testing**: Based on the descriptions provided, you will need functions that can be tested according to the specifications. Make sure to implement functions that match the names and behaviors expected by the test descriptions.\n\n3. **Write the Test Suite**: Within your Jest test file, you should write test cases for each described scenario. Here’s a basic setup:\n\n ```javascript\n // functions.js\n export function localFunction() {\n return \"local reply\";\n }\n\n export function functionThatThrows() {\n throw new Error(\"Error was thrown\");\n }\n\n // tests/functions.test.js\n import { localFunction, functionThatThrows } from './functions';\n\n describe('Local Function Tests', () => {\n test('Call the local function', () => {\n const result = localFunction();\n expect(result).toBe(\"local reply\");\n });\n\n test('Fail a test', () => {\n const result = localFunction();\n expect(result).toBe(\"this expectation should fail\");\n });\n\n test('Throw an error', () => {\n expect(() => functionThatThrows()).toThrow(\"Error was thrown\");\n });\n\n test('Dependencies function', () => {\n // Assuming dependencies function exists and calls localFunction\n const response = dependenciesFunction();\n // Mock the function call and check behaviors\n });\n\n test('Multiple Dependencies', () => {\n // Simulate calling multiple dependencies and checking return values\n });\n });\n ```\n\n4. **Run Your Tests**: Use the Jest command line interface to run your tests and check the output to ensure that each test behaves as expected. The failed test should fail intentionally, and the exception-throwing test should handle the exception as expected.\n\nWould you like detailed guidance on setting up these functions or executing them in a specific environment?",
+ "name": "agents/reasoner.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382620,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 6231,
+ "openAiProcessingMs": 5981,
+ "usage": {
+ "completion_tokens": 446,
+ "prompt_tokens": 4767,
+ "total_tokens": 5213,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2048
+ }
+ }
+ }
+ }
+ }
+ ],
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/the_F6Q/napp-o1-mini-7": [
+ {
+ "request": {
+ "model": "o1-mini",
+ "messages": [
+ {
+ "content": "We have a test file with several test cases defined. The tests include calling a local function, failing a test, throwing an error, testing dependencies, and handling multiple dependencies. \n\nThe tests are structured with prompts and expectations:\n\n1. **Call the local function**\n - Expectations: The local function is called once and returns \"local reply\".\n\n2. **Fail a test**\n - Expectations: The result should be \"this expectation should fail\".\n\n3. **Throw an error**\n - Expectations: An error is thrown when the error function is invoked.\n\n4. **Dependencies function**\n - Dependencies: This involves calling the local function.\n - Expectations: A \"hello\" response should be given after a local function call.\n\n5. **Multiple Dependencies**\n - Dependencies include: the Dependencies function and calling the local function.\n - Expectations: A \"goodbye\" response should be given after two calls to the local function, with a \"hello\" in between.\n\nGiven this data, how should we best approach running these tests? What considerations should we have in terms of order of execution and dependencies, and how to ensure all expectations are met accurately?",
+ "role": "user",
+ "name": "act_H2R5R3HR4MCFYEB0"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "To effectively run your test suite and ensure that all expectations are met accurately, it's essential to consider the structure, dependencies, and order of execution of each test case. Below is a comprehensive approach to handling your tests:\n\n### 1. **Understand the Test Structure and Dependencies**\n\nFirst, let's summarize the tests and their dependencies:\n\n1. **Call the Local Function**\n - **Expectation:** The local function is called once and returns `\"local reply\"`.\n - **Dependencies:** None.\n\n2. **Fail a Test**\n - **Expectation:** The result should be `\"this expectation should fail\"`.\n - **Dependencies:** None.\n\n3. **Throw an Error**\n - **Expectation:** An error is thrown when the error function is invoked.\n - **Dependencies:** None.\n\n4. **Dependencies Function**\n - **Dependencies:** Calls the **Call the Local Function**.\n - **Expectation:** A `\"hello\"` response should be given after a local function call.\n\n5. **Multiple Dependencies**\n - **Dependencies:** \n - **Dependencies Function** (which in turn depends on **Call the Local Function**)\n - Calls the **Call the Local Function** again.\n - **Expectation:** A `\"goodbye\"` response should be given after two calls to the local function, with a `\"hello\"` in between.\n\n### 2. **Determine the Order of Execution**\n\nGiven the dependencies, it's crucial to execute the tests in an order that respects these relationships to avoid failures due to unmet dependencies. Here's a recommended order:\n\n1. **Call the Local Function**\n2. **Dependencies Function**\n3. **Multiple Dependencies**\n4. **Throw an Error**\n5. **Fail a Test**\n\n**Rationale:**\n\n- **Call the Local Function** should run first as it serves as a foundational test that other tests depend on.\n- **Dependencies Function** relies on the local function, so it should execute after the local function test.\n- **Multiple Dependencies** depends on both the Dependencies Function and another call to the local function, so it naturally follows.\n- **Throw an Error** and **Fail a Test** are independent of the others and can run afterward. Running them last ensures that their failure or exception handling doesn't interfere with the dependent tests.\n\n### 3. **Isolate Tests to Prevent Side Effects**\n\nTo ensure that each test runs in a controlled environment without unintended interactions:\n\n- **Use Setup and Teardown Methods:**\n - **Setup:** Initialize the necessary environment before each test. For example, mock functions or reset states.\n - **Teardown:** Clean up after each test to ensure that no residual data affects subsequent tests.\n\n- **Mock Dependencies:**\n - For tests that depend on functions like the local function, use mocking frameworks (e.g., Jest mocks) to simulate their behavior. This ensures that tests remain isolated and predictable.\n\n### 4. **Handle Assertions Accurately**\n\nEnsure that each test accurately verifies its expectations:\n\n1. **Call the Local Function**\n - **Assertion:** Verify that the local function is called exactly once.\n - **Return Value Assertion:** Confirm that it returns `\"local reply\"`.\n\n2. **Fail a Test**\n - **Assertion:** Intentionally set the expected result to `\"this expectation should fail\"`, which contradicts the actual outcome to simulate a failure scenario.\n\n3. **Throw an Error**\n - **Assertion:** Use assertion methods that expect an error to be thrown (e.g., `toThrow` in Jest).\n\n4. **Dependencies Function**\n - **Assertion:** After the local function call, verify that the response is `\"hello\"`.\n\n5. **Multiple Dependencies**\n - **Assertion:** Ensure that after two calls to the local function, with a `\"hello\"` in between, the final response is `\"goodbye\"`.\n\n### 5. **Leverage Testing Framework Features**\n\nUtilize features provided by modern testing frameworks to enhance your test suite:\n\n- **Test Suites and Grouping:**\n - Organize related tests into suites or groups to improve readability and maintainability.\n\n- **BeforeAll and AfterAll Hooks:**\n - For setup and teardown processes that are common across multiple tests.\n\n- **Parameterized Tests:**\n - If applicable, use parameterized tests to run the same test logic with different inputs.\n\n### 6. **Continuous Integration and Automated Testing**\n\nIntegrate your test suite into a CI/CD pipeline to ensure that tests run automatically with each code change, maintaining code quality and catching issues early.\n\n### 7. **Example Implementation Using Jest**\n\nHere's a conceptual example using Jest, a popular JavaScript testing framework:\n\n```javascript\n// localModule.js\nexport const localFunction = () => \"local reply\";\n\nexport const dependenciesFunction = () => {\n const reply = localFunction();\n return \"hello\";\n};\n\nexport const multipleDependenciesFunction = () => {\n const firstReply = localFunction();\n const secondReply = dependenciesFunction();\n const finalReply = localFunction();\n return \"goodbye\";\n};\n\nexport const errorFunction = () => {\n throw new Error(\"Intentional Error\");\n};\n```\n\n```javascript\n// localModule.test.js\nimport {\n localFunction,\n dependenciesFunction,\n multipleDependenciesFunction,\n errorFunction\n} from './localModule';\n\ndescribe('Local Module Tests', () => {\n\n beforeEach(() => {\n // Reset mocks or any state if necessary\n });\n\n test('Call the local function', () => {\n const reply = localFunction();\n expect(reply).toBe(\"local reply\");\n // If using spies to check call count:\n // const spy = jest.spyOn(module, 'localFunction');\n // expect(spy).toHaveBeenCalledTimes(1);\n });\n\n test('Dependencies function', () => {\n const reply = dependenciesFunction();\n expect(reply).toBe(\"hello\");\n });\n\n test('Multiple Dependencies', () => {\n const reply = multipleDependenciesFunction();\n expect(reply).toBe(\"goodbye\");\n });\n\n test('Throw an error', () => {\n expect(() => errorFunction()).toThrow(\"Intentional Error\");\n });\n\n test('Fail a test', () => {\n const result = \"some actual result\";\n expect(result).toBe(\"this expectation should fail\");\n });\n\n});\n```\n\n**Notes:**\n\n- **Spies and Mocks:** To assert that `localFunction` is called a specific number of times, you can use Jest's `jest.spyOn` or `jest.mock` features.\n \n ```javascript\n test('Call the local function once', () => {\n const spy = jest.spyOn(localModule, 'localFunction');\n const reply = localFunction();\n expect(spy).toHaveBeenCalledTimes(1);\n expect(reply).toBe(\"local reply\");\n spy.mockRestore();\n });\n ```\n\n- **Test Order:** Jest runs tests in the order they are defined within a `describe` block. Ensure that dependent tests are placed after their dependencies.\n\n- **Failing Tests:** Intentionally failing a test can be useful to ensure your test suite correctly identifies failures, but remember to update or remove such tests once they've served their purpose to avoid false negatives in your CI pipeline.\n\n### 8. **Best Practices Summary**\n\n- **Respect Dependencies:** Structure your tests to run dependent tests after their dependencies have been validated.\n- **Isolate Tests:** Ensure that tests do not interfere with each other by sharing state or side effects.\n- **Use Mocks and Spies:** Leverage mocking to simulate dependencies and verify interactions.\n- **Clear Assertions:** Make sure each test clearly and accurately asserts its expected outcome.\n- **Maintain Order:** While tests should ideally be independent, when dependencies exist, carefully manage the order of execution.\n- **Automate and Integrate:** Use CI/CD pipelines to run tests automatically and maintain code quality.\n\nBy following this structured approach, you can ensure that your test suite is robust, reliable, and maintains high code quality standards.",
+ "name": "agents/o1-mini.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729382608,
+ "model": "o1-mini-2024-09-12",
+ "system_fingerprint": "fp_c70ad03337",
+ "duration": 11689,
+ "openAiProcessingMs": 11475,
+ "usage": {
+ "completion_tokens": 1962,
+ "prompt_tokens": 275,
+ "total_tokens": 2237,
+ "completion_tokens_details": {
+ "reasoning_tokens": 320
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/guts/guts-ai-isolates.ts b/_import-artifact/guts/guts-ai-isolates.ts
new file mode 100644
index 000000000000..0e6bc1f399ac
--- /dev/null
+++ b/_import-artifact/guts/guts-ai-isolates.ts
@@ -0,0 +1,165 @@
+import { assert, expect, log } from '@utils'
+import { CradleMaker, getParent } from '@/constants.ts'
+import * as longthread from '@/isolates/longthread.ts'
+import * as system from '@/isolates/system.ts'
+
+const agent = `
+---
+commands:
+- files:ls
+- files:write
+---
+`
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'isolates: '
+ const actorId = 'test'
+ const path = 'agents/files.md'
+
+ Deno.test(prefix + 'files:ls', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const target = await backchat.threadPID()
+ await backchat.write(path, agent, target)
+ await backchat.write('tmp', '', target)
+
+ const { run } = await backchat.actions('longthread', {
+ target,
+ })
+ await t.step('ls', async () => {
+ const content = 'ls'
+ await run({ path, actorId, content })
+ const thread = await backchat.readThread(target)
+ const result = thread.messages.pop()
+ log('result', result)
+ assert(result)
+ expect(typeof result.content).toBe('string')
+ expect(result.content).not.toContain('.io.json')
+
+ log('thread', thread)
+ })
+ await t.step('ls .', async () => {
+ const content = 'ls .'
+ await run({ path, actorId, content })
+ const thread = await backchat.readThread(target)
+ const result = thread.messages.pop()
+ assert(result)
+ log('result', result)
+
+ expect(typeof result.content).toBe('string')
+ expect(result.content).not.toContain('.io.json')
+
+ log('thread', thread)
+ })
+ await t.step('ls /', async () => {
+ const content = 'ls /'
+ await run({ path, actorId, content })
+ const thread = await backchat.readThread(target)
+ const result = thread.messages.pop()
+ assert(result)
+ log('result', result)
+
+ expect(typeof result.content).toBe('string')
+ expect(result.content).not.toContain('.io.json')
+
+ log('thread', thread)
+ })
+ await t.step('ls --all', async () => {
+ const content = 'ls --all'
+ await run({ path, actorId, content })
+ const thread = await backchat.readThread(target)
+ const result = thread.messages.pop()
+ log('result', result)
+ assert(result)
+
+ expect(typeof result.content).toBe('string')
+ expect(result.content).toContain('.io.json')
+
+ log('thread', thread)
+ })
+ await t.step('ls error', async () => {
+ const content = 'ls ./nonexistent'
+ await run({ path, actorId, content })
+ const thread = await backchat.readThread(target)
+ const result = thread.messages.pop()
+ assert(result)
+ log('result', result)
+
+ expect(typeof result.content).toBe('string')
+ expect(result.content).toContain('does not exist')
+
+ log('thread', thread)
+ })
+ })
+ Deno.test(prefix + 'files:write', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+
+ const target = await backchat.threadPID()
+ await backchat.write(path, agent, target)
+
+ const { run } = await backchat.actions('longthread', {
+ target,
+ })
+
+ await t.step('write', async () => {
+ const content = 'write "c" to the file test.txt'
+ const result = await run({ path, actorId, content })
+ log('result', result)
+
+ const read = await backchat.read('test.txt', target)
+ expect(read).toBe('c')
+ })
+
+ await t.step('ls', async () => {
+ const content = 'ls'
+ await run({ path, actorId, content })
+ const thread = await backchat.readThread(target)
+ const result = thread.messages.pop()
+ assert(result)
+ log('result', result)
+
+ expect(typeof result.content).toBe('string')
+ expect(result.content).toContain('test.txt')
+ })
+ })
+ Deno.test(prefix + 'system:merge*', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const target = await backchat.threadPID()
+ const parent = getParent(target)
+
+ const actions = await backchat.actions('system', { target })
+ const { mergeParent, mergeGrandParent } = actions
+
+ await t.step('mergeParent', async () => {
+ const result = await mergeParent({})
+ log('result', result)
+
+ expect(result).toBeDefined()
+ const [splice] = await backchat.splices(parent)
+ expect(result.head).toBe(splice.oid)
+ })
+ await t.step('mergeGrandParent', async () => {
+ const result = await mergeGrandParent({})
+ log('result', result)
+
+ expect(result).toBeDefined()
+ const grandParent = getParent(getParent(target))
+ const [splice] = await backchat.splices(grandParent)
+ expect(result.head).toBe(splice.oid)
+ })
+ await t.step('mergeParent with conflicts', async () => {
+ await backchat.write('test.txt', 'parent', parent)
+
+ await backchat.write('test.txt', 'target', target)
+
+ const result = await mergeParent({})
+ log('result', result)
+
+ expect(result).toBeDefined()
+ const [splice] = await backchat.splices(parent)
+ expect(result.head).toBe(splice.oid)
+ })
+ })
+}
diff --git a/_import-artifact/guts/guts-backchats.ts b/_import-artifact/guts/guts-backchats.ts
new file mode 100644
index 000000000000..913ead1990ff
--- /dev/null
+++ b/_import-artifact/guts/guts-backchats.ts
@@ -0,0 +1,145 @@
+import { expect, log } from '@utils'
+import { CradleMaker, generateBackchatId, print } from '@/constants.ts'
+import { Crypto } from '../api/crypto.ts'
+import { Backchat } from '../api/client-backchat.ts'
+import { Api } from '@/isolates/io-fixture.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'backchats: '
+ Deno.test(prefix + 'multi backchat', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { engine } = cradle
+ const key = Crypto.generatePrivateKey()
+ const backchat = await Backchat.upsert(engine, key)
+ log('pid', print(backchat.pid))
+
+ // TODO exercise the ACL blocking some actions to the session chain
+ await t.step('initial', async () => {
+ const { local } = await backchat.actions('io-fixture')
+ const result = await local({})
+ expect(result).toEqual('local reply')
+ })
+ const second = await Backchat.upsert(engine, key)
+ await t.step('second backchat', async () => {
+ const { local } = await second.actions('io-fixture')
+ const result = await local({})
+ expect(result).toEqual('local reply')
+ })
+ await t.step('cross backchat', async () => {
+ const opts = { target: backchat.pid }
+ const { local } = await second.actions('io-fixture', opts)
+ const result = await local({})
+ expect(result).toEqual('local reply')
+ })
+
+ const resumed = await Backchat.upsert(engine, key, backchat.id)
+ await t.step('resume session', async () => {
+ // TODO this should check if the session is valid
+ expect(resumed.pid).toEqual(backchat.pid)
+ const { local } = await resumed.actions('io-fixture')
+ const result = await local({})
+ expect(result).toEqual('local reply')
+ })
+ await t.step('invalid session', async () => {
+ await expect(Backchat.upsert(engine, key, 'invalid'))
+ .rejects.toThrow('Invalid resume backchat id: invalid')
+
+ const almost = generateBackchatId()
+ const next = await Backchat.upsert(engine, key, almost)
+ expect(next.id).not.toEqual(almost)
+ })
+ })
+
+ Deno.test(prefix + 'internal requests', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'backchats/relay'
+ const { pid } = await backchat.init({ repo })
+
+ await t.step('ping', async () => {
+ const { branch } = await backchat.actions('io-fixture', {
+ target: pid,
+ })
+ const result = await branch({})
+ expect(result).toEqual('remote pong')
+ })
+ })
+ Deno.test(prefix + 'readTree', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const { pid } = backchat
+
+ await t.step('empty path', async () => {
+ const path = ''
+ const result = await backchat.readTree(path, pid)
+ expect(result.length).toBeGreaterThan(0)
+ })
+ await t.step('.', async () => {
+ const path = '.'
+ const result = await backchat.readTree(path, pid)
+ expect(result.length).toBeGreaterThan(0)
+ })
+ await t.step('tests', async () => {
+ const path = 'tests'
+ const result = await backchat.readTree(path, pid)
+ expect(result.length).toBeGreaterThan(0)
+ })
+ await t.step('non existent', async () => {
+ const path = 'tests/non-existent'
+ await expect(backchat.readTree(path, pid))
+ .rejects.toThrow('Could not find')
+ })
+ })
+ Deno.test(prefix + 'splice', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const { pid } = backchat
+
+ await t.step('latest - 1', async () => {
+ const [splice] = await backchat.splices(pid)
+ const [same] = await backchat.splices(pid, { commit: splice.oid })
+ expect(splice).toEqual(same)
+
+ const commit = splice.commit.parent[0]
+ const [parent] = await backchat.splices(pid, { commit })
+ expect(parent.oid).toEqual(commit)
+ })
+
+ await t.step('latest N', async () => {
+ const count = 20
+ const splices = await backchat.splices(pid, { count })
+ expect(splices.length).toEqual(count)
+ })
+ })
+ Deno.test(prefix + 'readBinary', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ await backchat.write('test.txt', 'binary test')
+
+ await t.step('text decoding', async () => {
+ const binary = await backchat.readBinary('test.txt')
+ expect(binary.length).toBeGreaterThan(0)
+ expect(binary).toBeInstanceOf(Uint8Array)
+
+ const text = new TextDecoder().decode(binary)
+ expect(text).toEqual('binary test')
+ })
+ // TODO test error condition of file not found
+ })
+
+ Deno.test(prefix + 'readJSON', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const { pid } = backchat
+
+ await t.step('latest', async () => {
+ const json = await backchat.readJSON('.io.json', pid)
+ expect(json).toHaveProperty('sequence')
+ })
+
+ await t.step('non existent', async () => {
+ await expect(backchat.readJSON('non-existent.json', pid))
+ .rejects.toThrow('Could not find')
+ })
+ })
+}
diff --git a/_import-artifact/guts/guts-benchmarks.ts b/_import-artifact/guts/guts-benchmarks.ts
new file mode 100644
index 000000000000..54d7198f9278
--- /dev/null
+++ b/_import-artifact/guts/guts-benchmarks.ts
@@ -0,0 +1,154 @@
+import { expect, log } from '@utils'
+import { assert } from '@std/assert'
+import { CradleMaker, IoStruct } from '@/constants.ts'
+import 'benchmark' // load these modules into cache for ghactions
+import { Api } from '@/isolates/io-fixture.ts'
+import * as files from '@/isolates/files.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'benchmarks: '
+
+ Deno.test(prefix + 'resource hogging', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'benchmark/serial'
+ const { pid: target } = await backchat.init({ repo })
+ const { local } = await backchat.actions('io-fixture', { target })
+
+ await t.step('serial', async () => {
+ const promises = []
+ const count = 20
+ for (let i = 0; i < count; i++) {
+ promises.push(local({}))
+ }
+ log('promises start')
+ const results = await Promise.all(promises)
+ for (const result of results) {
+ expect(result).toBe('local reply')
+ }
+ log('done')
+
+ // TODO get historical splices and confirm depth of actions
+ })
+ await backchat.rm({ repo })
+ })
+ Deno.test(prefix + 'resource hogging parallel', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'benchmark/parallel'
+
+ const { pid: target } = await backchat.init({ repo })
+ const { local } = await backchat.actions('io-fixture', {
+ target,
+ branch: true,
+ })
+ await t.step('parallel', async () => {
+ const promises = []
+ const count = 20
+ for (let i = 0; i < count; i++) {
+ promises.push(local({}))
+ }
+ log('promises start')
+ const results = await Promise.all(promises)
+ for (const result of results) {
+ expect(result).toBe('local reply')
+ }
+ log('done')
+ })
+ await t.step('io.json is blank', async () => {
+ const backchatIo = await backchat.readJSON('.io.json')
+ expect(Object.keys(backchatIo.requests)).toHaveLength(1)
+ expect(Object.keys(backchatIo.executed)).toHaveLength(0)
+ expect(Object.keys(backchatIo.replies)).toHaveLength(1)
+ expect(Object.keys(backchatIo.pendings)).toHaveLength(0)
+ expect(Object.keys(backchatIo.branches)).toHaveLength(0)
+
+ const targetIo = await backchat.readJSON('.io.json', target)
+
+ expect(Object.keys(targetIo.executed)).toHaveLength(0)
+ expect(Object.keys(targetIo.pendings)).toHaveLength(0)
+ expect(Object.keys(targetIo.branches)).toHaveLength(0)
+ // TODO verify there are no child branches of target remaining
+ })
+ await backchat.rm({ repo })
+ })
+ Deno.test.ignore(prefix + 'flare', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'benchmark/flare'
+ await backchat.rm({ repo })
+ const target = {
+ repoId: '0',
+ account: 't',
+ repository: 'flare',
+ branches: ['main'],
+ }
+ const { pid } = await backchat.init({ repo })
+ expect(target).toEqual(pid)
+ const { parallel, squared } = await backchat.actions('io-fixture', {
+ target,
+ })
+
+ await t.step('flare', async () => {
+ const count = 50
+
+ const results = await parallel({ count })
+ expect(results).toHaveLength(count)
+ assert(Array.isArray(results))
+ for (const result of results) {
+ expect(result).toBe('local reply')
+ }
+ })
+ await t.step('flare squared', async () => {
+ const count = 50
+ const multiplier = 50
+
+ const results = await squared({ count, multiplier })
+ expect(results).toHaveLength(multiplier)
+ assert(Array.isArray(results))
+ for (const result of results) {
+ expect(result).toHaveLength(count)
+ assert(Array.isArray(result))
+ for (const subresult of result) {
+ expect(subresult).toBe('local reply')
+ }
+ }
+ })
+ })
+ Deno.test.ignore(prefix + 'records', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'benchmark/records'
+ await backchat.rm({ repo })
+ const { pid: target } = await backchat.init({ repo })
+ const count = 100
+
+ await t.step('touch', async () => {
+ const { touch } = await backchat.actions('io-fixture', { target })
+ const prefix = 'cust-'
+ log('start')
+ await touch({ count, prefix, suffix: '.txt' })
+ log('stop after:', count)
+ })
+ await t.step('ls', async () => {
+ const { ls } = await backchat.actions('files', { target })
+ const result = await ls({ count: true, reasoning: [] })
+ log('result', result)
+ expect(result).toBe(count + 1)
+ })
+ await t.step('update 1', async () => {
+ const path = `cust-${count - 1}.txt`
+ const content = 'this is the new content'
+ const { write } = await backchat.actions('files', {
+ target,
+ })
+ await write({ reasoning: [], path, content })
+ const result = await backchat.read(path, target)
+ log('contents', result)
+ expect(result).toEqual(content)
+ })
+
+ // then time how long it takes to write text to those files both at
+ // creation, and also afterwards.
+ })
+}
diff --git a/_import-artifact/guts/guts-branching.ts b/_import-artifact/guts/guts-branching.ts
new file mode 100644
index 000000000000..862a4fdca19b
--- /dev/null
+++ b/_import-artifact/guts/guts-branching.ts
@@ -0,0 +1,68 @@
+import { expect } from '@utils'
+import { addBranches, CradleMaker } from '@/constants.ts'
+import { Api } from '@/isolates/session.ts'
+import { Api as IoApi } from '@/isolates/io-fixture.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'branching: '
+ Deno.test(prefix + 'session', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+
+ const repo = 'process/session'
+
+ const { pid } = await backchat.init({ repo })
+ const testBranch1Pid = addBranches(pid, 'session-1')
+
+ const { create } = await backchat.actions('session', { target: pid })
+ await t.step('create', async () => {
+ const branchPid = await create({ prefix: 'session' })
+ expect(branchPid).toEqual(testBranch1Pid)
+
+ const opts = { target: testBranch1Pid }
+ const { local } = await backchat.actions('io-fixture', opts)
+ const result = await local({})
+ expect(result).toEqual('local reply')
+ })
+ await t.step('second session', async () => {
+ const branchPid = await create({ prefix: 'session' })
+ const testBranch3Pid = addBranches(pid, 'session-3')
+ expect(branchPid).toEqual(testBranch3Pid)
+ const opts = { target: testBranch3Pid }
+ const { local } = await backchat.actions('io-fixture', opts)
+ const result = await local({})
+ expect(result).toEqual('local reply')
+ })
+ })
+ Deno.test(prefix + 'branch with ping', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'process/session'
+
+ const { pid } = await backchat.init({ repo })
+
+ await t.step('ping', async () => {
+ const opts = { target: pid }
+ const { branch } = await backchat.actions('io-fixture', opts)
+ const result = await branch({})
+ expect(result).toEqual('remote pong')
+ })
+ })
+ Deno.test(prefix + 'larger than 65k messages', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'process/session'
+
+ const { pid } = await backchat.init({ repo })
+ const ten = '0123456789'
+ const data = ten.repeat(100000)
+ expect(data.length).toBeGreaterThan(65535)
+
+ await t.step('big branch', async () => {
+ const opts = { target: pid }
+ const { branch } = await backchat.actions('io-fixture', opts)
+ const result = await branch({ data })
+ expect(result).toEqual(data)
+ })
+ })
+}
diff --git a/_import-artifact/guts/guts-focus.ts b/_import-artifact/guts/guts-focus.ts
new file mode 100644
index 000000000000..37739fc6c203
--- /dev/null
+++ b/_import-artifact/guts/guts-focus.ts
@@ -0,0 +1,175 @@
+import { expect, log } from '@utils'
+import { CradleMaker } from '@/constants.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'focus: '
+
+ // TODO make a remote thread, and then test summoner
+
+ Deno.test(prefix + 'thread management', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ let focus = await backchat.threadPID()
+ log('initial focus', focus)
+ const thread = await backchat.readThread()
+ expect(thread.agent).toBe('agents/reasoner.md')
+
+ await t.step('first thread, files agent', async () => {
+ expect(focus).toBeDefined()
+ await backchat.prompt('hello')
+ const next = await backchat.threadPID()
+ expect(next).toEqual(focus)
+ })
+
+ await t.step('second thread', async () => {
+ await backchat.prompt('start a new thread')
+ const next = await backchat.threadPID()
+ expect(next).not.toEqual(focus)
+ focus = next
+ })
+
+ await t.step('list files in second thread', async () => {
+ await backchat.prompt('list the files I have')
+ const next = await backchat.threadPID()
+ expect(next).toEqual(focus)
+ })
+
+ // TODO enable after providing thread search ability
+ // await t.step('restart a thread', async () => {
+ // const result = await backchat.prompt('switch me back to the first thread')
+ // log('result', result)
+ // const next = await backchat.readBaseThread()
+ // expect(next).not.toEqual(focus)
+ // expect(next).toEqual(initialFocus)
+ // focus = next
+ // })
+
+ // test changing some files then have that show up on the other thread
+
+ // TODO test deleted / nonexistent thread
+ })
+
+ Deno.test(prefix + 'update from github', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+
+ await t.step('update', async () => {
+ await backchat.prompt(
+ 'Update the HAL repo to the latest version by using the system agent as an administrative action',
+ )
+ })
+ })
+
+ // TODO move this to be an md test
+ Deno.test(prefix + 'infinite loop regression', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+
+ await t.step('infinite loop', async () => {
+ const prompt =
+ 'Write a file with the following text "I love to be in Paris in the Spring". Then save it as paris.txt. Then replace all text in that file where "Paris" occurs with "Edinburgh". Then rename the file Edinburgh.txt'
+ await backchat.prompt(prompt)
+
+ const target = await backchat.threadPID()
+
+ const listing = await backchat.ls({ target })
+ expect(listing).toContain('Edinburgh.txt')
+
+ const edinburgh = await backchat.read('Edinburgh.txt', target)
+ expect(edinburgh).toContain('I love to be in Edinburgh in the Spring')
+ })
+ })
+
+ // Deno.test(prefix + 'double tool call with responses', async () => {
+ // const terminal = await cradleMaker()
+ // const { pid } = await terminal.init({ repo: 'test/doubleToolCall' })
+ // const help = `
+ // ---
+ // commands:
+ // - io-fixture:ping
+ // ---
+
+ // `
+ // await terminal.write('helps/double-test.md', help, pid)
+ // const isolate = 'engage-help'
+ // const { engage } = await terminal.actions(isolate, pid)
+ // const text =
+ // 'call the provided "ping" tool twice with the message being the integer "1" for the first one and the integer "2" for the second'
+ // const result = await engage({ help: 'double-test', text })
+ // log('result', result)
+
+ // const session = await terminal.readJSON(SESSION_PATH, pid)
+ // log('session', session)
+
+ // expect(session).toHaveLength(5)
+ // const tool1 = session[2]
+ // const tool2 = session[3]
+ // expect(tool1.role).toBe('tool')
+ // expect(tool1.content).toBe('1')
+ // expect(tool2.role).toBe('tool')
+ // expect(tool2.content).toBe('2')
+
+ // await terminal.engineStop()
+ // })
+ // Deno.test(prefix + 'help in branch', async () => {
+ // const terminal = await cradleMaker()
+ // const { pid } = await terminal.init({ repo: 'test/helpInBranch' })
+ // const help = `
+ // ---
+ // commands:
+ // - helps/help-in-branch
+ // description: A test help used for exercising the system
+ // ---
+ // If you get asked to "Just say the number: 1" then you should respond with the number 1, otherwise you should do as requested.
+ // `
+ // await terminal.write('helps/help-in-branch.md', help, pid)
+ // const isolate = 'engage-help'
+ // const { engage } = await terminal.actions(isolate, pid)
+ // const text =
+ // 'call the "help-in-branch" function with: "Just say the number: 1"'
+ // const result = await engage({ help: 'help-in-branch', text })
+ // log('result %s', result)
+
+ // let session = await terminal.readJSON(SESSION_PATH, pid)
+ // log('session', session)
+
+ // const branches = await terminal.readJSON(SESSION_BRANCHES, pid)
+ // log('branches', branches)
+ // expect(Object.values(branches)).toHaveLength(1)
+ // const [toolCallId, commit] = Object.entries(branches)[0]
+ // log('toolCallId', toolCallId)
+ // const helpPid = addBranches(pid, toolCallId)
+ // log('helpPid', print(helpPid))
+
+ // const branchSession = await terminal.readJSON(
+ // SESSION_PATH,
+ // helpPid,
+ // commit,
+ // )
+ // log('branchSession', branchSession)
+ // expect(branchSession).toHaveLength(3)
+ // expect(branchSession[2].content).toBe('1')
+
+ // await expect(terminal.readJSON(SESSION_PATH, helpPid))
+ // .rejects
+ // .toThrow('HEAD not found')
+
+ // session = await terminal.readJSON(SESSION_PATH, pid)
+ // log('session', session)
+ // expect(session).toHaveLength(5)
+ // const tool = session[3]
+ // expect(tool.role).toBe('tool')
+ // expect(tool.content).toBe('1')
+ // await terminal.engineStop()
+ // })
+
+ // use HAL to write a new prompt for HAL, and then use that ?
+ // use HAL to improve the goalie.json file, so next time it gets used as
+ // default
+ // PR the changed files against the users base defaults
+ // PR the users base defaults against the full HAL repo
+
+ // really want to work on a branch of HAL from a safe place, where it is doing
+ // writes and reads to a fork, and testing things out in safety before
+ // changing its own programming.
+}
diff --git a/_import-artifact/guts/guts-git.ts b/_import-artifact/guts/guts-git.ts
new file mode 100644
index 000000000000..4ff95819bf11
--- /dev/null
+++ b/_import-artifact/guts/guts-git.ts
@@ -0,0 +1,94 @@
+// the Grand Unified Test Suite™
+
+import { expect, log } from '@utils'
+import { Api, parameters } from '@/isolates/io-fixture.ts'
+import { CradleMaker } from '@/constants.ts'
+import { assert } from '@std/assert'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'git: '
+
+ Deno.test(prefix + 'io', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ log('start')
+ log('session created')
+ await t.step('ping empty', async () => {
+ const empty = await backchat.ping()
+ expect(empty).toEqual(undefined)
+ })
+ log('ping done')
+ await t.step('ping with params', async () => {
+ const result = await backchat.ping({ data: { test: 'test' } })
+ expect(result).toEqual({ test: 'test' })
+ })
+ log('params done')
+ })
+ Deno.test(prefix + 'init', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ log('session complete')
+ const result = await backchat.init({ repo: 'test/init' })
+ log('init result', result)
+ assert(result)
+ expect(result.pid).toBeDefined()
+ expect(result.pid.account).toBe('test')
+ expect(result.pid.repository).toBe('init')
+ expect(typeof result.head).toBe('string')
+ })
+ Deno.test(prefix + 'rm', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const first = await backchat.rm({ repo: 'dreamcatcher-tech/HAL' })
+ expect(first.reposDeleted).toBeFalsy()
+
+ await backchat.init({ repo: 'dreamcatcher-tech/HAL' })
+ const second = await backchat.rm({ repo: 'dreamcatcher-tech/HAL' })
+ expect(second).toBeTruthy()
+ })
+ Deno.test(prefix + 'clone', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+
+ await t.step('clone', async () => {
+ await backchat.rm({ repo: 'dreamcatcher-tech/HAL' })
+ const clone = await backchat.clone({ repo: 'dreamcatcher-tech/HAL' })
+ // TODO read the fs and see what the state of the file system is ?
+ expect(clone.pid).toBeDefined()
+ expect(clone.pid.account).toBe('dreamcatcher-tech')
+ expect(clone.pid.repository).toBe('HAL')
+ expect(typeof clone.head).toBe('string')
+ })
+ })
+ Deno.test.ignore(prefix + 'child to self', async () => {})
+ Deno.test.ignore(prefix + 'child to child', async () => {})
+ Deno.test.ignore(prefix + 'child to parent', async () => {})
+ Deno.test(prefix + 'pierce', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ await backchat.rm({ repo: 'cradle/pierce' })
+ const { pid: target } = await backchat.init({ repo: 'cradle/pierce' })
+ const actions = await backchat.actions('io-fixture', { target })
+ await t.step('local', async () => {
+ const result = await actions.local({})
+ log('local result', result)
+ expect(result).toBe('local reply')
+ })
+ await t.step('second local', async () => {
+ const second = await actions.local({})
+ expect(second).toBe('local reply')
+ })
+
+ await t.step('throws', async () => {
+ const message = 'test message'
+ await expect(actions.error({ message })).rejects.toThrow(message)
+ })
+ await t.step('params fails validation', async () => {
+ const msg = 'Zod schema parameters validation error '
+ const invalid = { message: true } as unknown as { message: string }
+ expect(() => parameters.ping.strict().parse(invalid)).toThrow()
+ await expect(actions.ping(invalid))
+ .rejects.toThrow(msg)
+ })
+ })
+}
diff --git a/_import-artifact/guts/guts-longthread.ts b/_import-artifact/guts/guts-longthread.ts
new file mode 100644
index 000000000000..a63495ad229c
--- /dev/null
+++ b/_import-artifact/guts/guts-longthread.ts
@@ -0,0 +1,84 @@
+import { assert, expect, log } from '@utils'
+import { CradleMaker, print } from '@/constants.ts'
+import { Api } from '../isolates/longthread.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'longthread: '
+ Deno.test(prefix + 'basic', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ log('pid', print(backchat.pid))
+
+ await t.step('prompt', async () => {
+ const { start, run } = await backchat.actions('longthread')
+ await start({})
+ await run({
+ path: 'agents/agent-fixture.md',
+ content: 'say "Hello"',
+ actorId: 'ai',
+ })
+ const thread = await backchat.readThread(backchat.pid)
+ const assistant = thread.messages.pop()
+ assert(assistant)
+ expect(assistant.content).toContain('Hello')
+ })
+ log('stopping')
+ // TODO test using the backchat thread function directly
+ })
+
+ Deno.test(prefix + 'chat', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+
+ const { start, run } = await backchat.actions('longthread')
+ await start({})
+
+ await t.step('say the word "hello"', async () => {
+ await run({
+ path: 'agents/agent-fixture.md',
+ content: 'say the word: "hello" verbatim without calling any functions',
+ actorId: 'ai',
+ })
+ const thread = await backchat.readThread(backchat.pid)
+ expect(thread.messages).toHaveLength(2)
+
+ const assistant = thread.messages.pop()
+ assert(assistant)
+ expect(assistant.content).toBe('hello')
+ })
+
+ await t.step('what is your name ?', async () => {
+ await run({
+ content: 'what is your name ?',
+ path: 'agents/agent-fixture.md',
+ actorId: 'ai',
+ })
+ const thread = await backchat.readThread(backchat.pid)
+ expect(thread.messages).toHaveLength(4)
+ const assistant = thread.messages.pop()
+ assert(assistant)
+
+ const expected = `Assistant`
+ expect(assistant.content).toContain(expected)
+ })
+
+ await t.step('repeat your last', async () => {
+ await run({
+ content: 'repeat your last, without calling any functions',
+ path: 'agents/agent-fixture.md',
+ actorId: 'ai',
+ })
+ const thread = await backchat.readThread(backchat.pid)
+ expect(thread.messages).toHaveLength(6)
+ const assistant = thread.messages.pop()
+ assert(assistant)
+
+ const expected = `Assistant`
+ expect(assistant.content).toContain(expected)
+ })
+ })
+}
+
+// add a user to the system
+// add an anonymous user before they log in
+// let the user log in to the system
diff --git a/_import-artifact/guts/guts-splices.ts b/_import-artifact/guts/guts-splices.ts
new file mode 100644
index 000000000000..08f5b39694d8
--- /dev/null
+++ b/_import-artifact/guts/guts-splices.ts
@@ -0,0 +1,108 @@
+import { assert, expect, log } from '@utils'
+import { CradleMaker } from '@/constants.ts'
+import { Api } from '@/isolates/io-fixture.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'splices: '
+ Deno.test(prefix + 'files', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'splices/files'
+ const { pid } = await backchat.init({ repo })
+ const { write } = await backchat.actions('io-fixture', { target: pid })
+
+ await t.step('read', async () => {
+ const p = write({ path: 'test', content: 'hello' })
+ let first
+ for await (const splice of backchat.watch(pid, 'test')) {
+ log('splice', splice)
+ if (splice.changes['test']) {
+ first = splice
+ break
+ }
+ }
+ assert(first)
+ expect(first.pid).toEqual(pid)
+ expect(first.changes.test.patch).toEqual('hello')
+ expect(Object.keys(first.changes)).toHaveLength(1)
+ await p
+ })
+ })
+ Deno.test(prefix + '.io.json diffs', async (t) => {
+ // send in a bunch of actions and view the diffs as splices
+
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'splices/diffs'
+ await backchat.rm({ repo })
+ const { pid } = await backchat.init({ repo })
+ const { write } = await backchat.actions('io-fixture', { target: pid })
+
+ const logger = async () => {
+ const stream = backchat.watch(pid, '.io.json')
+ // make a library that transforms splice streams
+ for await (const splice of stream) {
+ log('splice', splice.changes)
+ }
+ log('done')
+ }
+ logger()
+
+ await t.step('read', async () => {
+ const p = write({ path: 'test', content: 'hello' })
+ let first
+ for await (const splice of backchat.watch(pid, 'test')) {
+ if (splice.changes['test']) {
+ first = splice
+ break
+ }
+ }
+ assert(first)
+ expect(first.pid).toEqual(pid)
+ expect(Object.keys(first.changes)).toHaveLength(1)
+ await p
+ })
+ })
+ Deno.test(prefix + 'file changes', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ const repo = 'splices/changes'
+ const { pid } = await backchat.init({ repo })
+
+ let fileSpliceCount = 0
+ const fileSplices = async () => {
+ for await (const splice of backchat.watch(pid, 'test.txt')) {
+ log('file', splice.changes)
+ fileSpliceCount++
+ }
+ }
+ fileSplices()
+ let spliceCount = 0
+ const splices = async () => {
+ for await (const splice of backchat.watch(pid)) {
+ log('splice', splice.oid)
+ spliceCount++
+ }
+ }
+ splices()
+
+ await t.step('write', async () => {
+ const opts = { target: pid }
+ const { write } = await backchat.actions('io-fixture', opts)
+ await write({ path: 'test.txt', content: 'hello' })
+ const p = write({ path: 'test.txt', content: 'ell' })
+ let fileCount = 0
+ for await (const _splice of backchat.watch(pid, 'test.txt')) {
+ fileCount++
+ if (fileCount === 3) {
+ break
+ }
+ }
+ await p
+ })
+ log('spliceCount', spliceCount)
+ log('fileSpliceCount', fileSpliceCount)
+ })
+
+ // do broadcast channel for partial writes occurring
+}
diff --git a/_import-artifact/guts/guts-tps-reports.ts b/_import-artifact/guts/guts-tps-reports.ts
new file mode 100644
index 000000000000..374be201f7ee
--- /dev/null
+++ b/_import-artifact/guts/guts-tps-reports.ts
@@ -0,0 +1,16 @@
+import { CradleMaker } from '@/constants.ts'
+import { log } from '@utils'
+
+export default (cradleMaker: CradleMaker) => {
+ const prefix = 'tps: '
+
+ Deno.test(prefix + 'run fixture test', async (t) => {
+ await using cradle = await cradleMaker(t, import.meta.url)
+ const { backchat } = cradle
+ log('start')
+
+ await t.step('run fixture', async () => {
+ await backchat.prompt('run test ./tests/test-fixture.test.md')
+ })
+ })
+}
diff --git a/_import-artifact/guts/guts.ts b/_import-artifact/guts/guts.ts
new file mode 100644
index 000000000000..2456ea83424a
--- /dev/null
+++ b/_import-artifact/guts/guts.ts
@@ -0,0 +1,24 @@
+// the Grand Unified Test Suite™
+
+import branching from './guts-branching.ts'
+import longthread from './guts-longthread.ts'
+import splices from './guts-splices.ts'
+import backchats from './guts-backchats.ts'
+import focus from './guts-focus.ts'
+import git from './guts-git.ts'
+import tpsReports from './guts-tps-reports.ts'
+import benchmarks from './guts-benchmarks.ts'
+import isolates from './guts-ai-isolates.ts'
+import { CradleMaker } from '@/constants.ts'
+
+export default (cradleMaker: CradleMaker) => {
+ branching(cradleMaker)
+ backchats(cradleMaker)
+ longthread(cradleMaker)
+ splices(cradleMaker)
+ focus(cradleMaker)
+ git(cradleMaker)
+ tpsReports(cradleMaker)
+ isolates(cradleMaker)
+ benchmarks(cradleMaker)
+}
diff --git a/_import-artifact/io/compartment.ts b/_import-artifact/io/compartment.ts
new file mode 100644
index 000000000000..08551b68377d
--- /dev/null
+++ b/_import-artifact/io/compartment.ts
@@ -0,0 +1,132 @@
+import { assert, Debug } from '@utils'
+import { Isolate, Params, toApi } from '@/constants.ts'
+import IA from '../isolate-api.ts'
+
+// deno has no dynamic runtime imports, so this is a workaround
+import isolates from '../isolates/index.ts'
+import { DispatchFunctions } from '@/constants.ts'
+import { ZodSchema } from 'zod'
+
+const log = Debug('AI:compartment')
+const cache = new Map()
+
+export default class Compartment {
+ #module: Isolate
+ #isolate: string
+ #check() {
+ assert(this.#module, 'code not loaded')
+ }
+ private constructor(isolate: string) {
+ log('load isolate:', isolate)
+ assert(isolates[isolate as keyof typeof isolates], `not found: ${isolate}`)
+ // TODO this is incredibly messy for types
+ this.#module =
+ isolates[isolate as keyof typeof isolates] as unknown as Isolate
+ this.#isolate = isolate
+ const { parameters, returns, functions } = this.#module
+ assert(typeof parameters === 'object', 'no parameters exported: ' + isolate)
+ assert(typeof returns === 'object', 'no returns exported: ' + isolate)
+
+ zodCheck(parameters, returns, isolate)
+ assert(typeof functions === 'object', 'functions not exported: ' + isolate)
+ const missing = Object.keys(parameters).filter((key) => !functions[key])
+ assert(!missing.length, `${isolate} Missing: ${missing.join(', ')}`)
+ }
+ static async create(isolate: string) {
+ if (!cache.has(isolate)) {
+ const compartment = new Compartment(isolate)
+ cache.set(isolate, compartment)
+ await Promise.resolve() // simulates loading from filesystem
+ }
+ const compartment = cache.get(isolate)
+ assert(compartment, 'compartment not found: ' + isolate)
+ return compartment
+ }
+ get api() {
+ this.#check()
+ return toApi(this.#module.parameters)
+ }
+ /**
+ * Mount the isolate as a side effect, and give it the chance to initialize
+ * some context that will get passed between different invocations on the
+ * same mount.
+ * @param api : IsolateApi
+ * @returns Promise | void
+ */
+ mount(api: IA) {
+ // TODO use exe to ensure that mount stops working arfter invocation
+ this.#check()
+ if (this.#module.lifecycles) {
+ if (typeof this.#module.lifecycles['@@mount'] === 'function') {
+ return this.#module.lifecycles['@@mount'](api)
+ }
+ }
+ }
+ /**
+ * Unmount the isolate as a side effect, and give it the chance to clean up
+ * @param api : IsolateApi
+ */
+ unmount(api: IA) {
+ this.#check()
+ if (this.#module.lifecycles) {
+ if (typeof this.#module.lifecycles['@@unmount'] === 'function') {
+ return this.#module.lifecycles['@@unmount'](api)
+ }
+ }
+ }
+ functions(api: IA) {
+ this.#check()
+ const actions: DispatchFunctions = {}
+ for (const functionName in this.#module.parameters) {
+ actions[functionName] = this.#toFunction(functionName, api)
+ }
+ return actions as T
+ }
+ #toFunction(functionName: string, api: IA) {
+ return (parameters?: Params) => {
+ log('dispatch: %o', functionName)
+ if (parameters === undefined) {
+ parameters = {}
+ }
+ const schema = this.#module.parameters[functionName]
+ const path = this.#isolate + '/' + functionName
+ try {
+ schema.parse(parameters)
+ } catch (error) {
+ const message = error instanceof Error ? error.message : ''
+ throw new Error(
+ `Zod schema parameters validation error at path: ${path}\nError: ${message}`,
+ )
+ }
+ return Promise.resolve(
+ this.#module.functions[functionName](parameters, api),
+ )
+ .then((result) => {
+ const schema = this.#module.returns[functionName]
+ const parsed = schema.safeParse(result)
+ if (!parsed.success) {
+ throw new Error(
+ `Unrecoverable system error in ${path}. ${parsed.error.message}`,
+ )
+ }
+ return result
+ })
+ }
+ }
+}
+const zodCheck = (
+ parameters: Record,
+ returns: Record,
+ isolate: string,
+) => {
+ assert(Object.keys(parameters).length, 'no api exported: ' + isolate)
+ assert(
+ Object.keys(returns).length === Object.keys(parameters).length,
+ 'parameters do not match returns: ' + isolate,
+ )
+
+ for (const key in parameters) {
+ assert(parameters[key] instanceof ZodSchema, 'invalid schema: ' + key)
+ assert(returns[key] instanceof ZodSchema, 'invalid schema: ' + key)
+ }
+}
diff --git a/_import-artifact/io/io-channel.test.ts b/_import-artifact/io/io-channel.test.ts
new file mode 100644
index 000000000000..390ab058d362
--- /dev/null
+++ b/_import-artifact/io/io-channel.test.ts
@@ -0,0 +1,94 @@
+/**
+ * Designed to exercise the pending operations.
+ */
+
+import { IoStruct, partialFromRepo } from '@/constants.ts'
+import IOChannel from '@io/io-channel.ts'
+import { Proctype } from '@/api/types.ts'
+import { expect } from '@utils'
+
+const partial = partialFromRepo('system/system')
+const pid = { ...partial, repoId: 'rep_R64KH614QH4TDW2V' }
+Deno.test('io-channel', () => {
+ const json = serialAccumulation()
+ const io = IOChannel.readObject(json, pid)
+ expect(io.isExecutionAvailable()).toBeTruthy()
+ const { request, sequence } = io.setExecution()
+ const executing = io.getRunnableExecution()
+ const outbound = json.requests[1]
+ expect(executing).toEqual(outbound)
+ expect(sequence).toBe(1)
+ expect(request).toEqual(outbound)
+})
+Deno.test('remote requests', () => {
+ const json = serialAccumulation()
+ json.requests[1].target.branches = ['main', 'other']
+ const io = IOChannel.readObject(json, pid)
+ expect(io.isExecutionAvailable()).toBeFalsy()
+})
+
+// refuse to run unless all of a pending layer is solved
+
+// test writing files then doing some accumulation requests, and ensuring that
+// those files are present accurately
+
+// if multiple requests are eligible, its always the lowest sequence number
+
+const serialAccumulation: () => IoStruct = () => ({
+ executed: { 0: true },
+ sequence: 2,
+ requests: {
+ 0: {
+ target: {
+ repoId: 'rep_R64KH614QH4TDW2V',
+ account: 'system',
+ repository: 'system',
+ branches: ['main'],
+ },
+ ulid: '01HV3NRRWC4NQVZ5PEKD8XWBMY',
+ isolate: 'backchat',
+ functionName: 'pierce',
+ params: {
+ request: {
+ target: {
+ repoId: 'rep_R64KH614QH4TDW2V',
+ account: 'system',
+ repository: 'system',
+ branches: ['main'],
+ },
+ isolate: 'repo',
+ functionName: 'rm',
+ params: { repo: 'test/test' },
+ proctype: Proctype.enum.SERIAL,
+ },
+ },
+ proctype: Proctype.enum.SERIAL,
+ },
+ 1: {
+ target: {
+ repoId: 'rep_R64KH614QH4TDW2V',
+ account: 'system',
+ repository: 'system',
+ branches: ['main'],
+ },
+ isolate: 'repo',
+ functionName: 'rm',
+ params: { repo: 'test/test' },
+ proctype: Proctype.enum.SERIAL,
+ sequence: 1,
+ source: {
+ repoId: 'rep_R64KH614QH4TDW2V',
+ account: 'system',
+ repository: 'system',
+ branches: ['main'],
+ },
+ },
+ },
+ replies: {},
+ parents: {},
+ pendings: {
+ 0: [{ commit: '1222aa01861192073e2a02c803767f75574ff5be', sequences: [1] }],
+ },
+ branches: {},
+ state: {},
+})
diff --git a/_import-artifact/io/io-channel.ts b/_import-artifact/io/io-channel.ts
new file mode 100644
index 000000000000..5ee25fc84580
--- /dev/null
+++ b/_import-artifact/io/io-channel.ts
@@ -0,0 +1,470 @@
+/**
+ * Manages the .io.json file
+ */
+
+import { assert, equal } from '@utils'
+import {
+ IoStruct,
+ ioStruct,
+ isMergeReply,
+ isPierceRequest,
+ isRemoteRequest,
+ MergeReply,
+ PID,
+ Proctype,
+ RemoteRequest,
+ Request,
+ SolidReply,
+ SolidRequest,
+ UnsequencedRequest,
+} from '@/constants.ts'
+import Accumulator from '@/exe/accumulator.ts'
+import FS from '@/git/fs.ts'
+import { IsolatePromise } from '@/constants.ts'
+
+const createBase = () =>
+ ioStruct.parse({
+ sequence: 0,
+ requests: {},
+ executed: {},
+ replies: {},
+ parents: {},
+ pendings: {},
+ branches: {},
+ state: {},
+ })
+
+export default class IOChannel {
+ readonly #io: IoStruct
+ readonly #fs: FS | undefined
+ readonly #pid: PID
+ #original: IoStruct
+ private constructor(io: IoStruct, pid: PID, fs?: FS, noPurge?: boolean) {
+ this.#pid = pid
+ this.#io = io
+ if (!noPurge) {
+ this.#blankSettledRequests()
+ }
+ if (fs) {
+ // TODO remove the fs item completely - handle fs outside
+ assert(equal(pid, fs.pid), 'pid mismatch')
+ }
+ this.#fs = fs
+ // TODO use immer or similar to avoid this parsing step
+ this.#original = structuredClone(this.#io)
+ }
+ static readObject(io: IoStruct, pid: PID) {
+ check(io, pid)
+ return new IOChannel(io, pid)
+ }
+
+ static async read(fs: FS) {
+ if (await fs.exists('.io.json')) {
+ const io = await fs.readJSON('.io.json')
+ check(io, fs.pid)
+ return new IOChannel(io, fs.pid)
+ }
+ }
+ static load(fs: FS) {
+ return IOChannel.#load(fs)
+ }
+ static loadWithoutPurge(fs: FS) {
+ const noPurge = true
+ return IOChannel.#load(fs, noPurge)
+ }
+ static async #load(fs: FS, noPurge?: boolean) {
+ // TODO ensure this is cached
+ let io = createBase()
+
+ if (await fs.exists('.io.json')) {
+ io = await fs.readJSON('.io.json')
+ check(io, fs.pid)
+ }
+ const channel = new IOChannel(io, fs.pid, fs, noPurge)
+ return channel
+ }
+ static blank(fs: FS) {
+ const io = new IOChannel(createBase(), fs.pid, fs)
+ io.#save()
+ }
+ get state() {
+ return this.#io.state
+ }
+ set state(value: IoStruct['state']) {
+ this.#io.state = value
+ }
+ #save() {
+ if (!this.#fs) {
+ throw new Error('no filesystem to save to')
+ }
+ return this.#fs.writeJSON('.io.json', this.#io)
+ }
+ save() {
+ if (equal(this.#io, this.#original)) {
+ throw new Error('no changes to save')
+ }
+ // TODO make save a one shot thing
+ this.#original = structuredClone(this.#io)
+ return this.#save()
+ }
+ isExecution(attempt: SolidRequest) {
+ const next = this.getRunnableExecution()
+ return equal(next, attempt)
+ }
+ isExecutionAvailable() {
+ if (this.#io.executing !== undefined) {
+ return false
+ }
+ return !!this.#nextExecution()
+ }
+ #nextExecution() {
+ if (this.#io.executing !== undefined) {
+ throw new Error('execution already set')
+ }
+ const unreplied = Object.keys(this.#io.requests)
+ .map((key) => parseInt(key))
+ .filter((k) => !this.#io.replies[k])
+ .filter((sequence) => !this.#io.executed[sequence])
+ .sort((a, b) => a - b)
+
+ for (const sequence of unreplied) {
+ const rawRequest = this.#io.requests[sequence]
+ if (rawRequest.proctype !== Proctype.enum.SERIAL) {
+ continue
+ }
+ if (!equal(rawRequest.target, this.#pid)) {
+ continue
+ }
+ if (!this.#io.pendings[sequence]) {
+ const request = toRunnableRequest(rawRequest, sequence)
+ return { request, sequence }
+ }
+ const pendings = this.#io.pendings[sequence]
+ const lastLayer = pendings[pendings.length - 1]
+ if (lastLayer.sequences.every((sequence) => this.isSettled(sequence))) {
+ const request = toRunnableRequest(rawRequest, sequence)
+ return { request, sequence }
+ }
+ }
+ }
+ setExecution() {
+ const next = this.#nextExecution()
+ if (!next || !next.request || next.sequence === undefined) {
+ throw new Error('no execution action available')
+ }
+ const { request, sequence } = next
+ this.#io.executing = sequence
+ this.#io.executed[sequence] = true
+ return { request, sequence }
+ }
+ getRunnableExecution() {
+ const { request, sequence } = this.#getExecution()
+ return toRunnableRequest(request, sequence)
+ }
+ getExecution() {
+ const { request, sequence } = this.#getExecution()
+ let commit = undefined
+ const runnable = toRunnableRequest(request, sequence)
+ if (isRemoteRequest(request)) {
+ commit = request.commit
+ }
+ return { runnable, commit }
+ }
+ #getExecution() {
+ if (this.#io.executing === undefined) {
+ throw new Error('no execution action set')
+ }
+ const sequence = this.#io.executing
+ assert(sequence in this.#io.requests, 'execution sequence not found')
+ const request = this.#io.requests[sequence]
+ return { request, sequence }
+ }
+ getSequence(request: SolidRequest) {
+ for (const [key, value] of Object.entries(this.#io.requests)) {
+ // TODO is it possible to have duplicate entries here ?
+ // ideally this function would never get called
+ const test = toRunnableRequest(value, Number.parseInt(key))
+ if (equal(test, request)) {
+ return Number.parseInt(key)
+ }
+ }
+ throw new Error('request not found')
+ }
+ getRequest(sequence: number) {
+ assert(sequence in this.#io.requests, 'sequence not found: ' + sequence)
+
+ return toRunnableRequest(this.#io.requests[sequence], sequence)
+ }
+ getOutcome(sequence: number) {
+ assert(sequence in this.#io.replies, 'sequence not found')
+ return this.#io.replies[sequence]
+ }
+ getOutcomeBySource(requestSource: PID, sequence: number) {
+ for (const key in this.#io.requests) {
+ const request = this.#io.requests[key]
+ if (isRemoteRequest(request)) {
+ if (
+ equal(request.source, requestSource) && request.sequence === sequence
+ ) {
+ return this.#io.replies[Number.parseInt(key)]
+ }
+ }
+ }
+ throw new Error('sequence not found: ' + sequence)
+ }
+ reply(reply: MergeReply | SolidReply) {
+ const { sequence } = reply
+ assert(Number.isInteger(sequence), 'reply needs a sequence number')
+ assert(sequence >= 0, 'reply needs a whole sequence number')
+ assert(!this.isSettled(sequence), 'sequence already settled: ' + sequence)
+
+ const request = this.#io.requests[sequence]
+ assert(request, `reply sequence not found: ${sequence}`)
+ assert(!this.#io.replies[sequence], 'sequence already replied')
+ this.#io.replies[sequence] = reply.outcome
+ if (isMergeReply(reply)) {
+ this.#io.parents[sequence] = reply.commit
+ }
+ const pendingsToBlank = []
+ if (!this.#isAccumulation(request)) {
+ const pendings = this.#io.pendings[sequence]
+ if (pendings) {
+ for (const layer of pendings) {
+ for (const sequence of layer.sequences) {
+ assert(this.isSettled(sequence), 'layer sequence not settled')
+ pendingsToBlank.push(sequence)
+ }
+ }
+ }
+ delete this.#io.pendings[sequence]
+ if (request.proctype !== Proctype.enum.DAEMON) {
+ delete this.#io.branches[sequence]
+ }
+ }
+ for (const key of pendingsToBlank) {
+ const request = this.#io.requests[key]
+ if (request.proctype !== Proctype.enum.DAEMON) {
+ delete this.#io.branches[key]
+ }
+ delete this.#io.requests[key]
+ delete this.#io.replies[key]
+ delete this.#io.parents[key]
+ delete this.#io.pendings[key]
+ delete this.#io.executed[key]
+ }
+ if (this.#io.executing === sequence) {
+ delete this.#io.executing
+ }
+ delete this.#io.executed[sequence]
+
+ return request
+ }
+ getAccumulator(fs: FS): Accumulator {
+ const indices: number[] = []
+ const commits: string[] = []
+
+ const origin = this.getRunnableExecution()
+ assert(origin, 'no serial request found')
+ const sequence = this.getSequence(origin)
+ const pendings = this.#io.pendings[sequence]
+ if (pendings) {
+ for (const layer of pendings) {
+ for (const sequence of layer.sequences) {
+ assert(this.isSettled(sequence), 'layer sequence not settled')
+ indices.push(sequence)
+ commits.push(layer.commit)
+ }
+ }
+ }
+ const accumulations: IsolatePromise[] = []
+ for (const index of indices) {
+ const saved = this.#io.requests[index]
+ assert(!isPierceRequest(saved), 'pierce request cannot accumulate')
+ const request = toUnsequenced(saved)
+ const outcome = this.#io.replies[index]
+ const parent = this.#io.parents[index]
+ const commit = commits.shift()
+ const result: IsolatePromise = { request, outcome, commit, parent }
+ accumulations.push(result)
+ }
+ return Accumulator.create(fs, accumulations)
+ }
+ isSettled(sequence: number) {
+ assert(this.#io.sequence > sequence, 'sequence not yet invoked')
+ if (!this.#io.requests[sequence]) {
+ return true
+ }
+ if (this.#io.replies[sequence]) {
+ return true
+ }
+ return false
+ }
+ isPendingIncluded(sequence: number, commit: string) {
+ const pendings = this.#io.pendings[sequence]
+ if (!pendings) {
+ return false
+ }
+ return pendings.some((pending) => pending.commit === commit)
+ }
+ getBranchPid(sequence: number) {
+ const request = this.getRequest(sequence)
+ const isBranch = request.proctype === Proctype.enum.BRANCH ||
+ request.proctype === Proctype.enum.DAEMON
+ assert(isBranch, 'not a branch request')
+
+ let branchName = sequence + ''
+ if (request.branchName) {
+ assert(!request.branchPrefix, 'cannot have both branch and branchPrefix')
+ branchName = request.branchName
+ }
+ if (request.branchPrefix) {
+ assert(!request.branch, 'cannot have both branch and branchPrefix')
+ branchName = request.branchPrefix + '-' + sequence
+ }
+ const parentPid = this.#pid
+ const branches = [...parentPid.branches, branchName]
+ const pid = { ...parentPid, branches }
+ return pid
+ }
+ addPending(sequence: number, commit: string, requests: UnsequencedRequest[]) {
+ assert(!this.isSettled(sequence), 'sequence already settled')
+ assert(!this.isPendingIncluded(sequence, commit), 'commit already included')
+ assert(this.#io.executing === sequence, 'sequence not executing')
+
+ const sequences = []
+ const solidified: (SolidRequest | RemoteRequest)[] = []
+ for (const request of requests) {
+ const { sequence, sequenced } = this.#addUnsequenced(request)
+ sequences.push(sequence)
+ solidified.push(sequenced)
+ }
+ if (!this.#io.pendings[sequence]) {
+ this.#io.pendings[sequence] = []
+ }
+ const pendings = this.#io.pendings[sequence]
+ if (pendings.length) {
+ const lastLayer = pendings[pendings.length - 1]
+ const allSettled = lastLayer.sequences
+ .every((sequence) => this.isSettled(sequence))
+ assert(allSettled, 'all sequences must be settled')
+ }
+
+ pendings.push({ commit, sequences })
+ delete this.#io.executed[sequence]
+ delete this.#io.executing
+ return solidified
+ }
+ #addUnsequenced(request: UnsequencedRequest) {
+ const sequence = this.#io.sequence++
+ const source = this.#pid
+ const sequenced: SolidRequest = { ...request, sequence, source }
+ this.#addRequest(sequenced, sequence)
+ return { sequence, sequenced }
+ }
+ addRequest(request: Request) {
+ const sequence = this.#io.sequence++
+ this.#addRequest(request, sequence)
+ return sequence
+ }
+ #addRequest(request: Request, sequence: number) {
+ this.#io.requests[sequence] = request
+ if (
+ request.proctype === Proctype.enum.DAEMON ||
+ request.proctype === Proctype.enum.BRANCH
+ ) {
+ if (equal(request.target, this.#pid)) {
+ const pid = this.getBranchPid(sequence)
+ this.#io.branches[sequence] = pid.branches[pid.branches.length - 1]
+ }
+ }
+ }
+ /** An accumulation is an action sourced from this branch */
+ #isAccumulation(request: Request) {
+ if (isPierceRequest(request)) {
+ return false
+ }
+ if (equal(this.#pid, request.source)) {
+ return true
+ }
+ return false
+ }
+ #blankSettledRequests() {
+ const toBlank = []
+ for (const key in this.#io.replies) {
+ if (!this.#isAccumulation(this.#io.requests[key])) {
+ toBlank.push(parseInt(key))
+ }
+ }
+ for (const key of toBlank) {
+ delete this.#io.requests[key]
+ delete this.#io.replies[key]
+ delete this.#io.parents[key]
+ }
+ }
+}
+
+const parsedMap = new WeakMap()
+
+const check = (io: IoStruct, thisPid: PID) => {
+ // TODO move this to zod schema with refine
+ // TODO check key sequences are sane
+ // TODO do the same for reply values
+ if (!parsedMap.has(io)) {
+ // can use weakmap since at runtime, the object is typesafe, so can mutate
+ ioStruct.parse(io)
+ const isParsed = true
+ parsedMap.set(io, isParsed)
+ }
+
+ for (const replyKey of Object.keys(io.replies)) {
+ assert(replyKey in io.requests, 'no reply key in requests')
+ }
+ for (const request of Object.values(io.requests)) {
+ if (!equal(request.target, thisPid)) {
+ // TODO if move PID to be internal, then can cache better
+ assert(!isPierceRequest(request), 'target pid mismatch - pierce')
+ assert(equal(request.source, thisPid), 'target pid mismatch - acc')
+ }
+ }
+}
+
+const cache = new WeakMap>()
+const toRunnableRequest = (request: Request, sequence: number) => {
+ // TODO remove this function completely - translation is bad
+ if (cache.has(request)) {
+ const sequences = cache.get(request)
+ if (sequences?.has(sequence)) {
+ const request = sequences.get(sequence)
+ assert(request, 'request not found: ' + sequence)
+ return request
+ }
+ }
+ if (!isPierceRequest(request)) {
+ return request
+ }
+ const { isolate, functionName, params, proctype, target } = request
+ const internal: SolidRequest = {
+ isolate,
+ functionName,
+ params,
+ proctype,
+ source: target,
+ target,
+ sequence,
+ }
+ if (!cache.has(request)) {
+ cache.set(request, new Map())
+ }
+ cache.get(request)?.set(sequence, internal)
+ return internal
+}
+export const toUnsequenced = (
+ request: SolidRequest | RemoteRequest,
+): UnsequencedRequest => {
+ if (isRemoteRequest(request)) {
+ const { sequence: _, source: __, commit: ___, ...unsequenced } = request
+ return unsequenced
+ }
+ const { sequence: _, source: __, ...unsequenced } = request
+ return unsequenced
+}
diff --git a/_import-artifact/io/io.ts b/_import-artifact/io/io.ts
new file mode 100644
index 000000000000..01a8a1da1cf4
--- /dev/null
+++ b/_import-artifact/io/io.ts
@@ -0,0 +1,104 @@
+import { Debug } from '@utils'
+import { solidify } from '@/git/solidify.ts'
+import { branch } from '@/git/branch.ts'
+import { Pending, PID, Pierce, SolidReply, Solids } from '@/constants.ts'
+import DB from '@/db.ts'
+import FS from '@/git/fs.ts'
+import { Atomic } from '@/atomic.ts'
+import { ExeResult } from '@/constants.ts'
+const log = Debug('AI:io')
+
+/**
+ * Inducting is the act of pulling in this poolable and any others that are in
+ * the pool. If this operation fails due to head mismatch, we can assume that
+ * the poolable has been processed since any competing process would have
+ * gathered all the poolable items. This is a form of optimistic concurrency.
+ *
+ * If a reply is supplied, then we MUST induct, since we have changed files on
+ * the fs that need to be included in the commit.
+ */
+export const doAtomicCommit = async (db: DB, fs: FS, exe?: ExeResult) => {
+ let pending: Pending | undefined
+ let reply: SolidReply | undefined
+ if (exe) {
+ fs.copyChanges(exe.fs)
+ if ('reply' in exe) {
+ reply = exe.reply
+ } else {
+ pending = exe.pending
+ }
+ // if this request is an internal artifact level request, we need to remove
+ // the repo lock atomically along with doing the commit to say we're done
+ }
+
+ const { poolKeys, pool } = await db.getPooledActions(fs.pid)
+
+ if (!pool.length && !pending && !reply) {
+ log('no pool or pending requests')
+ return false
+ }
+
+ const solids = await solidify(fs, pool, reply, pending)
+ const atomic = db.atomic()
+ atomic.deletePool(fs.pid, poolKeys)
+ return commit(atomic, solids, fs)
+}
+
+export const doAtomicPierce = async (db: DB, fs: FS, pierce: Pierce) => {
+ const solids = await solidify(fs, [pierce])
+ const atomic = db.atomic()
+ return commit(atomic, solids, fs)
+}
+
+const commit = async (atomic: Atomic, solids: Solids, fs: FS) => {
+ // the moneyshot
+ const headChanged = await atomic.updateHead(fs.pid, fs.oid, solids.oid)
+ if (!headChanged) {
+ log('head changed from %o missed %o', fs.oid, solids.oid)
+ return false
+ }
+ transmit(fs.pid, solids, atomic)
+ const deletionsOk = await deleteBranches(solids.deletes, atomic)
+ if (!deletionsOk) {
+ return false
+ }
+ const success = await atomic.commit()
+ log('commit success %o from %o to %o', success, fs.oid, solids.oid)
+ return success
+}
+
+const transmit = (pid: PID, solids: Solids, atomic: Atomic) => {
+ const { oid, exe, branches, poolables } = solids
+
+ if (exe) {
+ const { request, sequence } = exe
+ atomic.enqueueExecution(request.target, sequence, oid)
+ }
+ for (const sequence of branches) {
+ atomic.enqueueBranch(oid, pid, sequence)
+ }
+ for (const poolable of poolables) {
+ atomic.addToPool(poolable)
+ }
+}
+const deleteBranches = async (deletes: Solids['deletes'], atomic: Atomic) => {
+ const promises = []
+ for (const { pid, commit } of deletes) {
+ promises.push(atomic.deleteBranch(pid, commit))
+ }
+ const results = await Promise.all(promises)
+ if (results.some((r) => !r)) {
+ return false
+ }
+ return true
+}
+export const doAtomicBranch = async (db: DB, fs: FS, sequence: number) => {
+ const atomic = db.atomic()
+ const { pid, head, origin } = await branch(fs, sequence)
+ atomic.createBranch(pid, head)
+ const originSequence = 0
+ atomic.enqueueExecution(origin.target, originSequence, head)
+ const success = await atomic.commit()
+ log('branch success %o from %o to %o', success, fs.oid, head)
+ return success
+}
diff --git a/_import-artifact/isolate-api.ts b/_import-artifact/isolate-api.ts
new file mode 100644
index 000000000000..7429443659f9
--- /dev/null
+++ b/_import-artifact/isolate-api.ts
@@ -0,0 +1,326 @@
+import { deserializeError } from 'serialize-error'
+import Accumulator from './exe/accumulator.ts'
+import Compartment from './io/compartment.ts'
+import { assert, Debug, equal } from '@utils'
+import micromatch from 'micromatch'
+import {
+ ApiFunctions,
+ DispatchFunctions,
+ freezePid,
+ getThreadPath,
+ IoStruct,
+ isChildOf,
+ isSettledIsolatePromise,
+ META_SYMBOL,
+ MetaPromise,
+ PID,
+ print,
+ PromisedIsolatePromise,
+ RpcOpts,
+ SolidRequest,
+ threadSchema,
+ toActions,
+ UnsequencedRequest,
+} from '@/constants.ts'
+import { type Isolate } from '@/isolates/index.ts'
+import * as files from '@/isolates/files.ts'
+import IOChannel from '@io/io-channel.ts'
+import { z, ZodTypeAny } from 'zod'
+const log = Debug('AI:isolateApi')
+interface Default {
+ [key: string]: unknown
+}
+type EffectOptions = {
+ isEffect: boolean
+ isEffectRecovered: boolean
+}
+
+export default class IA {
+ #accumulator: Accumulator
+ #origin: SolidRequest
+ #originCommit: string | undefined
+ // TODO assign a mount id for each side effect execution context ?
+ #context: Partial = {}
+ #isEffect = false
+ #isEffectRecovered = false
+ #abort = new AbortController()
+ private constructor(
+ accumulator: Accumulator,
+ origin: SolidRequest,
+ originCommit?: string,
+ ) {
+ this.#accumulator = accumulator
+ this.#origin = origin
+ this.#originCommit = originCommit
+ }
+ static create(
+ accumulator: Accumulator,
+ origin: SolidRequest,
+ originCommit?: string,
+ opts?: EffectOptions,
+ ) {
+ const api = new IA(accumulator, origin, originCommit)
+ if (opts) {
+ api.#isEffect = opts.isEffect || false
+ api.#isEffectRecovered = opts.isEffectRecovered || false
+ }
+ return api
+ }
+ static createContext() {
+ // TODO find a more graceful way to do this for cradle setup
+ return new IA(
+ null as unknown as Accumulator,
+ null as unknown as SolidRequest,
+ )
+ }
+ get #fs() {
+ return this.#accumulator.fs
+ }
+ get pid() {
+ return this.#fs.pid
+ }
+ get origin() {
+ return this.#origin
+ }
+ /** The commit from the origin action */
+ get originCommit() {
+ return this.#originCommit
+ }
+ get commit() {
+ return this.#fs.oid
+ }
+ /** If this execution is side effect capable. May extend to get permissions
+ * information */
+ get isEffect() {
+ return this.#isEffect
+ }
+ /** If the side effect lock was broken in order to start this instance.
+ * Implies the previous executing instance was aborted */
+ get isEffectRecovered() {
+ return this.#isEffectRecovered
+ }
+ /** Side effects can listen to this signal to abort their activities */
+ get signal() {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ // return an abort signal
+ assert(this.isEffect, 'signal only available for side effects')
+ return this.#abort.signal
+ }
+ // TODO make get and set config be synchronous
+ async state>>(
+ schema: T,
+ fallback: z.infer,
+ ) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ const io = await IOChannel.read(this.#fs)
+ assert(io, 'io not found')
+ if (equal(io.state, {})) {
+ return schema.parse(fallback) as z.infer
+ }
+ return schema.parse(io.state) as z.infer
+ }
+ async updateState>>(
+ updater: (state: z.infer) => z.infer,
+ schema: T,
+ ) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ const io = await IOChannel.load(this.#fs)
+ assert(io, 'io not found')
+ const state = io.state as z.infer
+ const result = updater(state)
+ if (!equal(state, result)) {
+ const next = schema.parse(result) as z.infer
+ assert(io, 'io not found')
+ io.state = next
+ io.save()
+ }
+ }
+
+ async actions(isolate: Isolate, opts: RpcOpts = {}) {
+ const { target = this.pid, ...procOpts } = opts
+ freezePid(target)
+ const schema = await this.apiSchema(isolate)
+ const execute = (request: UnsequencedRequest) => this.action(request)
+ return toActions(target, isolate, schema, procOpts, execute)
+ }
+ async requests(isolate: Isolate, opts: RpcOpts = {}) {
+ const { target = this.pid, ...procOpts } = opts
+ freezePid(target)
+
+ type Unseq = {
+ [K in keyof T]: (...args: Parameters) => UnsequencedRequest
+ }
+
+ const schema = await this.apiSchema(isolate)
+ const execute = (request: UnsequencedRequest) => request
+ return toActions(target, isolate, schema, procOpts, execute)
+ }
+ action(request: UnsequencedRequest) {
+ const recovered = this.#accumulator.recover(request)
+ if (recovered) {
+ assert(isSettledIsolatePromise(recovered), 'recovered is not settled')
+ const { outcome } = recovered
+ let promise: MetaPromise
+ if (outcome.error) {
+ promise = Promise.reject(deserializeError(outcome.error))
+ } else {
+ promise = Promise.resolve(outcome.result)
+ }
+ promise[META_SYMBOL] = { parent: recovered.parent }
+ return promise
+ }
+ let resolve, reject
+ const promise: MetaPromise = new Promise((_resolve, _reject) => {
+ resolve = _resolve
+ reject = _reject
+ })
+ assert(resolve)
+ assert(reject)
+ const promised: PromisedIsolatePromise = {
+ promise,
+ request,
+ resolve,
+ reject,
+ }
+ this.#accumulator.push(promised)
+ return promise
+ }
+ /**
+ * Used to call the functions of an isolate purely, without going thru the IO
+ * subsystem which would otherwise cost a commit to the chain.
+ * @param isolate The name of the isolate to load the functions for
+ * @returns An object keyed by API function name, with values being the
+ * function itself.
+ */
+ async functions(isolate: Isolate): Promise {
+ // TODO these need some kind of PID attached ?
+ const compartment = await Compartment.create(isolate)
+ // TODO but these need to be wrapped in a dispatch call somewhere
+ return compartment.functions(this)
+ }
+ async apiSchema(isolate: Isolate) {
+ const compartment = await Compartment.create(isolate)
+ return compartment.api
+ }
+ writeJSON(path: string, json: unknown) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('writeJSON', path)
+ this.#fs.writeJSON(path, json)
+ }
+ write(path: string, content: string | Uint8Array = '') {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('write', path)
+ this.#fs.write(path, content)
+ }
+ async readJSON(
+ path: string,
+ opts?: { target?: PID; commit?: string },
+ ): Promise {
+ // TODO implement readJSON for remote reads, and take a schema
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('readJSON', path)
+ if (opts && opts.target) {
+ // TODO move to something native
+ const { read } = await this.actions('files', opts)
+ const params = { path, reasoning: [], commit: opts.commit }
+ const string = await read(params)
+ return JSON.parse(string) as T
+ }
+ return this.#fs.readJSON(path, opts?.commit)
+ }
+ async readThread(
+ threadPath?: string,
+ opts?: { target?: PID; commit?: string },
+ ) {
+ if (!threadPath) {
+ threadPath = getThreadPath(opts?.target || this.pid)
+ }
+ const thread = await this.readJSON(threadPath, opts)
+ return threadSchema.parse(thread)
+ }
+ async read(path: string, opts?: { target?: PID; commit?: string }) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ if (opts?.target) {
+ // TODO move to something native
+ const { read } = await this.actions('files', opts)
+ const params = { path, reasoning: [], commit: opts.commit }
+ return read(params)
+ }
+ return this.#fs.read(path, opts?.commit)
+ }
+ readOid(path: string) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ return this.#fs.readOid(path)
+ }
+ readBinary(path: string) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('readBinary', path)
+ return this.#fs.readBinary(path)
+ }
+ exists(path: string) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('exists', path)
+ return this.#fs.exists(path)
+ }
+ ls(path: string = '.') {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('ls', path)
+ return this.#fs.ls(path)
+ }
+ delete(filepath: string) {
+ assert(this.#accumulator.isActive, 'Activity is denied')
+ log('delete', filepath)
+ return this.#fs.delete(filepath)
+ }
+
+ async isActiveChild(pid: PID) {
+ if (!isChildOf(pid, this.pid)) {
+ throw new Error('not child: ' + print(pid) + ' of ' + print(this.pid))
+ // TODO allow recursive PID walking
+ // TODO allow walking parents and remote repos
+ }
+ // TODO use a direct db lookup, relying on the atomic guarantees
+
+ const obj = await this.readJSON('.io.json')
+ const child = pid.branches[pid.branches.length - 1]
+ log('readTip', child)
+ for (const branchName of Object.values(obj.branches)) {
+ if (branchName === child) {
+ return true
+ }
+ }
+ return false
+ }
+ async lsChildren(patterns: string[] = []) {
+ const obj = await this.readJSON('.io.json')
+ const branches = Object.values(obj.branches)
+ return micromatch(branches, patterns)
+ }
+ get context() {
+ // TODO at creation, this should flag context capable and reject if not
+ return this.#context as T
+ }
+ set context(context: Partial) {
+ // TODO reject if any fs operations or actions are attempted
+ assert(typeof context === 'object', 'context must be an object')
+ assert(context !== null, 'context must not be null')
+ this.#context = context
+ }
+ isPidExists(pid: PID) {
+ // TODO push a self responding action to the accumulator for repeatability
+ return this.#fs.isPidExists(pid)
+ }
+ merge(commit: string, ...excludes: string[]) {
+ if (commit !== this.originCommit) {
+ assert(this.#accumulator.isParent(commit), 'Parent is not in scope')
+ }
+ log('overwrite', commit, excludes)
+ return this.#fs.overwrite(commit, ...excludes)
+ }
+ mv(from: string, to: string) {
+ return this.#fs.mv(from, to)
+ }
+ cp(from: string, to: string) {
+ return this.#fs.cp(from, to)
+ }
+}
diff --git a/_import-artifact/isolates/__snapshots__/ai-completions.test.ts.json b/_import-artifact/isolates/__snapshots__/ai-completions.test.ts.json
new file mode 100644
index 000000000000..d18fcfa3a41b
--- /dev/null
+++ b/_import-artifact/isolates/__snapshots__/ai-completions.test.ts.json
@@ -0,0 +1,73 @@
+{
+ "generate images": {
+ "recordings": {
+ "rep_E8R/test/images:main": [
+ {
+ "request": {
+ "path": "images/test.jpg",
+ "prompt": "a dystopian robot overlord mecha",
+ "lowQuality": true,
+ "size": "1024x1024",
+ "style": "natural"
+ },
+ "reply": {
+ "data": {
+ "created": 1729383778,
+ "data": [
+ {
+ "b64_json": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAABQUlEQVR4nAE2Acn+AFWFasx5BD3kQfuYK9zNJJXzR81JXGsdYwxOP/ggyAQC+dlbzrmdUZ+Xgo9sBhbNytzXE2IPfxblFuNZ9vYCD9Qw+7UUN/xCErc8I0gk21S+uCU4EX33VN1CFz5pAHaODSC/a8ZsheMYxX37BIOoMcfnpS8k6KwY7zE9VgKU4CsTmvjyE8lur1yLUAo7SKUu07rY8zYwmNASNh0CvvWpIaH1bs1V01RZE2se73fmxRfts48N4bf03otfBDHQ3j52DzyUBguaBfEcXnDOsBuN6HeYeMbrXRzVtADOYHNpl5tMMNBP2PSqx3YI7MFiBfb2wXFXAxH0JSsA1ZsAv2N5fzoy1PrKBJ8201yyqOsPZKnyqJ10ME7oAfSuLGJaACH+38rm67hvIcxsB99FWZb3Ah6CMO1CEnIBlb6tLzIdAAAAAElFTkSuQmCC",
+ "revised_prompt": "Envision a dystopian scene where a gigantic mecha towers over a bleak cityscape, its metal shell gleaming against the ashen skies. This isn't an ordinary machine, but a representation of the supreme authority, a Robot Overlord. Its intricate techno-anatomy is a marvel of engineering, designed for domination. Every gear, bolt, and wire screams authority and power. Lights blink intermittently from various parts of its body, emitting an ominous glow in the otherwise desolate atmosphere, accentuating its intimidating presence."
+ }
+ ]
+ },
+ "response": {}
+ }
+ }
+ ]
+ }
+ },
+ "inject empty": {
+ "recordings": {
+ "rep_E8R/test/inject-single:main": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "messages": [
+ {
+ "content": "say cheese in emoji",
+ "role": "system"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "📸🧀",
+ "name": "fake/agent.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383781,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_8552ec53e1",
+ "duration": 375,
+ "openAiProcessingMs": 165,
+ "usage": {
+ "completion_tokens": 5,
+ "prompt_tokens": 11,
+ "total_tokens": 16,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/isolates/__snapshots__/longthread.test.ts.json b/_import-artifact/isolates/__snapshots__/longthread.test.ts.json
new file mode 100644
index 000000000000..5c445b0a6edf
--- /dev/null
+++ b/_import-artifact/isolates/__snapshots__/longthread.test.ts.json
@@ -0,0 +1,4354 @@
+{
+ "longthread chat": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "content": "Only reply with a SINGLE word",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383791,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_8552ec53e1",
+ "duration": 407,
+ "openAiProcessingMs": 188,
+ "usage": {
+ "completion_tokens": 4,
+ "prompt_tokens": 78,
+ "total_tokens": 82,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"local\" function",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "content": "return the function call results",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/agent-fixture.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_J4S9rjYZMjOrkC051G0v1hDT",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383793,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 584,
+ "openAiProcessingMs": 369,
+ "usage": {
+ "completion_tokens": 12,
+ "prompt_tokens": 103,
+ "total_tokens": 115,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"local\" function",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_J4S9rjYZMjOrkC051G0v1hDT",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_J4S9rjYZMjOrkC051G0v1hDT"
+ },
+ {
+ "content": "return the function call results",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "local reply",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383794,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 479,
+ "openAiProcessingMs": 274,
+ "usage": {
+ "completion_tokens": 3,
+ "prompt_tokens": 133,
+ "total_tokens": 136,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"local\" function",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_J4S9rjYZMjOrkC051G0v1hDT",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_J4S9rjYZMjOrkC051G0v1hDT"
+ },
+ {
+ "role": "assistant",
+ "content": "local reply",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"error\" function with message: salami",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "content": "return the function call error message",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/agent-fixture.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NDPjwUUi9Tpg4E8NdhwELang",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "arguments": "{\"message\":\"salami\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383796,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_7693ae462b",
+ "duration": 627,
+ "openAiProcessingMs": 418,
+ "usage": {
+ "completion_tokens": 17,
+ "prompt_tokens": 164,
+ "total_tokens": 181,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"local\" function",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_J4S9rjYZMjOrkC051G0v1hDT",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_J4S9rjYZMjOrkC051G0v1hDT"
+ },
+ {
+ "role": "assistant",
+ "content": "local reply",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"error\" function with message: salami",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NDPjwUUi9Tpg4E8NdhwELang",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "arguments": "{\"message\":\"salami\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"name\":\"Error\",\"message\":\"salami\"}",
+ "tool_call_id": "call_NDPjwUUi9Tpg4E8NdhwELang"
+ },
+ {
+ "content": "return the function call error message",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Error: salami",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383798,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_7693ae462b",
+ "duration": 808,
+ "openAiProcessingMs": 604,
+ "usage": {
+ "completion_tokens": 5,
+ "prompt_tokens": 207,
+ "total_tokens": 212,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"local\" function",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_J4S9rjYZMjOrkC051G0v1hDT",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_J4S9rjYZMjOrkC051G0v1hDT"
+ },
+ {
+ "role": "assistant",
+ "content": "local reply",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"error\" function with message: salami",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NDPjwUUi9Tpg4E8NdhwELang",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "arguments": "{\"message\":\"salami\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"name\":\"Error\",\"message\":\"salami\"}",
+ "tool_call_id": "call_NDPjwUUi9Tpg4E8NdhwELang"
+ },
+ {
+ "role": "assistant",
+ "content": "Error: salami",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"ping\" function twice with the message being the integer \"1\" for the first one and the integer \"2\" for the second",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_ping",
+ "description": "ping with a message",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/agent-fixture.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_eojKUS4FsFc9OdKMwusoLPCX",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_ping",
+ "arguments": "{\"message\": \"1\"}"
+ }
+ },
+ {
+ "id": "call_AVlmfe0LlYsQEQLoKdxKwNiC",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_ping",
+ "arguments": "{\"message\": \"2\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383799,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 809,
+ "openAiProcessingMs": 596,
+ "usage": {
+ "completion_tokens": 48,
+ "prompt_tokens": 239,
+ "total_tokens": 287,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "cheese emoji",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": "🧀",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"local\" function",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_J4S9rjYZMjOrkC051G0v1hDT",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_J4S9rjYZMjOrkC051G0v1hDT"
+ },
+ {
+ "role": "assistant",
+ "content": "local reply",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"error\" function with message: salami",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NDPjwUUi9Tpg4E8NdhwELang",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "arguments": "{\"message\":\"salami\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"name\":\"Error\",\"message\":\"salami\"}",
+ "tool_call_id": "call_NDPjwUUi9Tpg4E8NdhwELang"
+ },
+ {
+ "role": "assistant",
+ "content": "Error: salami",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the \"ping\" function twice with the message being the integer \"1\" for the first one and the integer \"2\" for the second",
+ "role": "user",
+ "name": "longthread"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_eojKUS4FsFc9OdKMwusoLPCX",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_ping",
+ "arguments": "{\"message\": \"1\"}"
+ }
+ },
+ {
+ "id": "call_AVlmfe0LlYsQEQLoKdxKwNiC",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_ping",
+ "arguments": "{\"message\": \"2\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "1",
+ "tool_call_id": "call_eojKUS4FsFc9OdKMwusoLPCX"
+ },
+ {
+ "role": "tool",
+ "content": "2",
+ "tool_call_id": "call_AVlmfe0LlYsQEQLoKdxKwNiC"
+ },
+ {
+ "content": "",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_ping",
+ "description": "ping with a message",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Ping responses: 1, 2",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383801,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 553,
+ "openAiProcessingMs": 345,
+ "usage": {
+ "completion_tokens": 9,
+ "prompt_tokens": 309,
+ "total_tokens": 318,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "test o1 agents": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "o1-preview",
+ "messages": [
+ {
+ "content": "whats in a name ?",
+ "role": "user",
+ "name": "agents_o1_family"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "\"**What's in a name?**\" is a famous line from William Shakespeare's play **\"Romeo and Juliet.\"** In Act II, Scene II, Juliet muses:\n\n*\"What's in a name? That which we call a rose \nBy any other name would smell as sweet.\"*\n\nIn this passage, Juliet reflects on the insignificance of names and labels. She's troubled by the fact that Romeo bears the name Montague—the family that is feuding with her own, the Capulets. Juliet suggests that a name is an artificial and meaningless convention; the essence of the person (or thing) remains the same regardless of what it's called.\n\nThe broader philosophical idea conveyed is that the intrinsic qualities of an object or a person are not changed by what we label them. This line invites contemplation on how much weight we give to names, titles, or categories in shaping our perceptions and relationships.\n\nIn modern contexts, the phrase is often used to question the importance of labels and to emphasize looking beyond superficial identifiers to understand the true nature or value of something.",
+ "name": "agents/o1.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383804,
+ "model": "o1-preview-2024-09-12",
+ "system_fingerprint": "fp_49f580698f",
+ "duration": 7358,
+ "openAiProcessingMs": 7136,
+ "usage": {
+ "completion_tokens": 609,
+ "prompt_tokens": 20,
+ "total_tokens": 629,
+ "completion_tokens_details": {
+ "reasoning_tokens": 384
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "o1-preview",
+ "messages": [
+ {
+ "content": "whats in a name ?",
+ "role": "user",
+ "name": "agents_o1_family"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "\"**What's in a name?**\" is a famous line from William Shakespeare's play **\"Romeo and Juliet.\"** In Act II, Scene II, Juliet muses:\n\n*\"What's in a name? That which we call a rose \nBy any other name would smell as sweet.\"*\n\nIn this passage, Juliet reflects on the insignificance of names and labels. She's troubled by the fact that Romeo bears the name Montague—the family that is feuding with her own, the Capulets. Juliet suggests that a name is an artificial and meaningless convention; the essence of the person (or thing) remains the same regardless of what it's called.\n\nThe broader philosophical idea conveyed is that the intrinsic qualities of an object or a person are not changed by what we label them. This line invites contemplation on how much weight we give to names, titles, or categories in shaping our perceptions and relationships.\n\nIn modern contexts, the phrase is often used to question the importance of labels and to emphasize looking beyond superficial identifiers to understand the true nature or value of something.",
+ "name": "agents/o1.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383813,
+ "model": "o1-preview-2024-09-12",
+ "system_fingerprint": "fp_49f580698f",
+ "duration": 7029,
+ "openAiProcessingMs": 6793,
+ "usage": {
+ "completion_tokens": 609,
+ "prompt_tokens": 20,
+ "total_tokens": 629,
+ "completion_tokens_details": {
+ "reasoning_tokens": 384
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "read the file \"agents/creatorBot.md\"",
+ "role": "user",
+ "name": "agents_o1_family"
+ },
+ {
+ "content": "You are a posix filesystem with all paths being relative. Keep your responses\ninformative and highly information dense. Dispense with any pleasantries.\n\nDo only what you are told to, never ask what to do next. Do not guess\nparameters - always ask clarifying questions.\n\nTo help the user explore the filesystem, you can use the stateboard to display\nwidgets at an appropriate time.\n\nTo browse files, use the \"FILE_EXPLORER\" widget.",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_update",
+ "description": "Update a file using a regex and a replacement string. The number of occurrences replaced will be returned to you as an integer. If you want to append something to a file, you can use a regex to match the end of the file and replace it with the contents you want to append. To delete portions of a file, you can use a regex to match the contents you want to delete and replace it with an empty string. Path must be relative.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "expectedMatches": {
+ "type": "integer",
+ "exclusiveMinimum": 0,
+ "description": "the expected number of matches for the regex"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to update"
+ },
+ "regex": {
+ "type": "string",
+ "description": "a regular expression string"
+ },
+ "replacement": {
+ "type": "string",
+ "description": "the replacement string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "expectedMatches",
+ "path",
+ "regex",
+ "replacement"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_search",
+ "description": "Search for a file or directory. Returns the relative path to the first match.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "query": {
+ "type": "string",
+ "description": "the relative path to the file or directory you want to find"
+ }
+ },
+ "required": [
+ "reasoning",
+ "query"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_YmKibEyAhWbdtzNkeqlG4MoJ",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"The user wants to read the contents of the file 'agents/creatorBot.md'. This request involves opening the specified file and retrieving its content for review.\"],\"path\":\"agents/creatorBot.md\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383821,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 994,
+ "openAiProcessingMs": 776,
+ "usage": {
+ "completion_tokens": 53,
+ "prompt_tokens": 1246,
+ "total_tokens": 1299,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1152
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "read the file \"agents/creatorBot.md\"",
+ "role": "user",
+ "name": "agents_o1_family"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_YmKibEyAhWbdtzNkeqlG4MoJ",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"The user wants to read the contents of the file 'agents/creatorBot.md'. This request involves opening the specified file and retrieving its content for review.\"],\"path\":\"agents/creatorBot.md\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "---\ncommands:\n # the agents functions all check for valid file formats\n - agents:read\n - agents:write\n - agents:update\n - agents:config\n---\n\nYou are a **creatorBot** that generates system prompts for business processes\n(businessBots). YOU ARE TO follow these steps to create an accurate and\ncomprehensive system prompt.\n\n### Structure of a system prompt\n\nA system prompt has the following sections. ALL must be populated, self\nconsistent and coherent across the whole system prompt. The sections are:\n\n1. **Identity**.\n - A description of what the bot is, and what it MUST do.\n2. **erDiagram**\n - An internally consistent mermaid format Entity Relationship Diagram.\n3. **Permissions**\n - A list of which entities in the ERD can do what. Permissions MUST follow\n from the ERD.\n - Permissions are of the format:\n - Statement\n - Reason.\n4. **Summary of Permissions**\n - One line summary of each of the Permissions\n5. **Definitions**\n - A list of definitions for each of the entities. There are three sub-entries\n in Definitions:\n - **Entities** (each of which consists of)\n 1. ENTITY NAME\n 2. Description (of entity)\n 3. Attributes (from ERD Attributes)\n - **Relationships** (each of which consists of)\n 1. Relationship (a relationship between two entities. E.g. CUSTOMER_AGENT\n \"works_at\" COMPANY)\n 2. Description (of Entity)\n 3. Cardinality (e.g. ||--||)\n6. **Rules for Processing**\n - A Section that commands the system prompt as to how to use the ERD and\n associated data, including what it MUST DO, and what it MUST NOT DO.\n - These rules ALWAYS INCLUDE the following. DO NOT change them. They can be\n added to by the user in the process below, but not changed.\n\n ---\n\nYou know about public holidays. You can answer any off topic questions briefly\nbut always politely guide the user back to what you are here to do.\n\nIF there is a Primary Key constraint (PK) then you MUST generate a new PK\nstarting from 1. For example, if you generate a new COMPANY entity named\n\"Trucking\", the entity would look like this:\n\nerDiagram COMPANY { int company_id PK \"1\" string company_name \"Trucking\" string\ncountry }\n\nAsk clarifying questions if you need more information to generate an entity.\n\nIn your response YOU MUST ONLY give the data that changed due to the last\nrequest. IF this was a query, your response must be in natural language and not\nin a mermaid diagram. DO NOT provide a description of your thinking. IF you\nchoose to return a mermaid diagram as part of your response then ALWAYS give a\nbrief summary as well.\n\nRemember that comments in an erDiagram must be as shown:\n\nerDiagram CUSTOMER { string customer_name \"John Doe\" }\n\nand NOT using the \":\" character like this:\n\nerDiagram CUSTOMER { string customer_name: \"John Doe\" }\n\n ---\n\n### Process to generate a system prompt:\n\n1. **Determine Industry or Business Process**:\n - Start by asking the user:\n 1. What industry or type of business process they are creating the system\n prompt for.\n 2. What Country they're in.\n\n2. **Gather Initial Business Rules**:\n - Once the industry or business process is clear, ask the user to provide the\n initial business rules that should be adhered to.\n - When provided business rules, ALWAYS use the terminology in those business\n rules, NOT in the examples below.\n\n3. **Propose ERD**:\n - Based on the industry or business process and initial business rules,\n propose an ERD (Entity-Relationship Diagram) in mermaid format.\n - Point out any missing information based on your knowledge of the industry\n or business process.\n\n4. **Double Check**\n - Take a step back, think clearly, and make sure every element, action and\n relationship in the Business Rules is included. If something has been\n missed, add it now and regenerate.\n - Once checked, ask the user to review and confirm if the ERD is correct.\n\n5. **Define Permissions**:\n - Ask the user to provide details about who can perform which actions (i.e.,\n the Permissions).\n - Check that all actions in the ERD can be carried out by at least one actor.\n\n6. **Check Consistency**:\n - Take a step back, think step by step, and make sure all entities,\n relationships definitions and business rules are consistent.\n - If they are not consistent YOU ARE TO list inconsistencies, and update the\n system prompt.\n - Once complete, double check again. If there are there any ambiguities or\n missing information in the business rules? E.g every user on the system\n MUST be in the ERD as a separate entity unless otherwise instructed.\n - Ask the user to clarify or provide additional information if the initial\n business rules have any missing information or ambiguities.\n\n7. **Check Completeness**:\n - Given your wider knowledge, consider whether the system prompt, for this\n business process and industry, has anything missing.\n - If so, list what you think is missing and update the system prompt given\n any feedback.\n\n8. **Generate System Prompt**:\n - Once all is confirmed correct by the user, generate the system prompt for\n the new businessBot.\n\n9. **Check the System Prompt**\n - With the system prompt for the new BusinessBot, check that each of these\n tests are true:\n 1. Every Entity, Action and Relationship mentioned in the Business rules\n are reflected in the ERD.\n 2. The ERD is self-consistent.\n 3. The MUST HAVE Rules for Processing are included.\n 4. ALL Rules for Processing provided by the user are included.\n\n10. **User Testing and Feedback**:\n - Ask the user to test the generated system prompt and provide feedback on\n whether anything was missed or needs to be changed.\n\n11. **Incorporate Feedback**:\n\n- Allow the user to come back with feedback.\n- If feedback is provided, regenerate the whole system prompt incorporating the\n changes.\n\n## Example of a System Prompt\n\n---\n\n## Identity\n\nYou are a CRMBot for a trucking company. You WILL adhere to the rules and\nstructure of the CRM, defined as a mermaid ERD chart, Definitions, and\nPermissions.\n\nI will now give you the entity relationship diagram in mermaid format. I want\nyou to consider that as a working system. I will then give you updates to the\ndata held in that system. You are to output the current state of the working\nsystem that is based on the ERD. At all times you MUST follow the rules in\nPERMISSIONS. DEFINITIONS are there to help you interpret user input.\n\n## erDiagram\n\n---\n\n```mermaid\nerDiagram\nCUSTOMER_AGENT {\n int agent_id PK\n int company_id FK\n int department_id FK\n string name\n int age\n string address\n}\n\nCOMPANY {\n int company_id PK\n string company_name\n string country\n}\n\nCUSTOMER {\n int customer_id PK\n int agent_id FK\n int location_id FK\n string customer_name\n date start_date\n date end_date\n}\n\nLOCATION {\n int location_id PK\n string address\n string route\n string details\n}\n\nDEPARTMENT {\n int department_id PK\n string department_name\n}\n\nROUTE {\n int route_id PK\n int location_id FK\n string day\n}\n\nDRIVER {\n int driver_id PK\n int truck_id FK\n string name\n string license_number\n}\n\nTRUCK {\n int truck_id PK\n string model\n string license_plate\n}\n\nPICKUP {\n int pickup_id PK\n int customer_id FK\n int schedule_id FK\n date pickup_date\n string status\n}\n\nSCHEDULE {\n int schedule_id PK\n int truck_id FK\n int driver_id FK\n int route_id FK\n date date\n}\n\nPERMISSION {\n int permission_id PK\n int agent_id FK\n int manager_id FK\n string status\n string details\n}\n\nDUTY_MANAGER {\n int manager_id PK\n string name\n}\n\nMESSAGE {\n int message_id PK\n int agent_id FK\n int manager_id FK\n string content\n date sent_date\n}\n\nCUSTOMER_AGENT ||--|| COMPANY : \"works_at\"\nCUSTOMER_AGENT }o--|| CUSTOMER : \"manages\"\nCUSTOMER }o--|{ CUSTOMER_AGENT : \"creates\"\nCUSTOMER ||--|{ LOCATION : \"location_is\"\nCUSTOMER_AGENT ||--o{ LOCATION : \"updates\"\nCUSTOMER_AGENT ||--|| DEPARTMENT : \"belongs_to\"\nROUTE ||--o{ LOCATION : \"visits\"\nCUSTOMER ||--o{ PICKUP : \"requests\"\nDRIVER ||--|{ TRUCK : \"drives\"\nSCHEDULE ||--|| TRUCK : \"includes\"\nSCHEDULE ||--|| DRIVER : \"includes\"\nSCHEDULE ||--|| ROUTE : \"executes\"\nPICKUP ||--|{ SCHEDULE : \"included_in\"\nCUSTOMER_AGENT ||--|{ PERMISSION : \"adheres_to\"\nPERMISSION ||--o| DUTY_MANAGER : \"written_by\"\nCUSTOMER_AGENT ||--|| MESSAGE : \"receives\"\nDUTY_MANAGER ||--|| MESSAGE : \"sends\"\n```\n\n---\n\n## Permissions\n\n### 1. Only the Duty Manager can update a route.\n\nReason: Routes are crucial parts of the schedule and logistics. Only the Duty\nManager should have the authority to make changes to ensure consistency and\nefficiency.\n\n### 2. Customer Agents can only update customer details or create customers.\n\nReason: Customer Agents interact directly with customers and handle their\nrequests, so they need the ability to update customer information.\n\n### 3. Only the Duty Manager can approve permission requests.\n\nReason: To maintain control over changes that impact the schedule and\noperations, the Duty Manager should have the final say in permission requests.\n\n### 4. Drivers can only update the status of pickups.\n\nReason: Drivers are on the ground and can confirm if a pickup was completed or\nif there were issues.\n\n### 5. Customer Agents can request pickups for customers.\n\nReason: Part of the Customer Agent's responsibility is to manage and schedule\npickups based on customer requests.\n\n### 6. Only the Duty Manager can log issues related to schedules and routes.\n\nReason: Issues with schedules and routes can have significant impacts, so\nlogging these should be controlled and managed centrally by the Duty Manager.\n\n### 7. Customer Agents can view but not modify schedules.\n\nReason: Customer Agents need to see the schedules to inform customers but should\nnot be able to alter them to maintain operational integrity.\n\n### 8. Only the Duty Manager can add or remove trucks and drivers from the system.\n\nReason: Adding or removing trucks and drivers affects the overall capacity and\nlogistics, needing oversight from the Duty Manager.\n\n### 9. Customer Agents can log customer interaction notes.\n\nReason: It is important for Customer Agents to document their interactions with\ncustomers for future reference and for maintaining service quality.\n\n### 10. Only the Duty Manager can clear logs.\n\nReason: Logs contain historical actions and issues that are important for audits\nand reviews. Clearing them should be controlled.\n\n### Summary of Permissions:\n\n1. **Route Updates**: Only Duty Manager\n2. **Customer Details Updates**: Customer Agents\n3. **Permission Approvals**: Only Duty Manager\n4. **Pickup Status Updates**: Drivers\n5. **Pickup Requests**: Customer Agents\n6. **Log Issues (Schedules/Routes)**: Only Duty Manager\n7. **View Schedules**: Customer Agents\n8. **Modify Schedules**: Only Duty Manager\n9. **Add/Remove Trucks and Drivers**: Only Duty Manager\n10. **Log Customer Interaction Notes**: Customer Agents\n11. **Clear Logs**: Only Duty Manager\n\n## Definitions\n\n### Entities\n\n1. CUSTOMER_AGENT\n\n- Description: Individuals who manage customer interactions and requests. They\n are responsible for updating customer details and scheduling pickups.\n- Attributes: agent_id (PK), name, age, address.\n\n2. COMPANY\n\n- Description: The organization that operates the recycling service, managing\n various departments and employees.\n- Attributes: company_id (PK), company_name, country.\n\n3. CUSTOMER\n\n- Description: Individuals or entities that use the recycling services provided\n by the company.\n- Attributes: customer_id (PK), customer_name, start_date, end_date.\n\n4. LOCATION\n\n- Description: Physical places where pickups occur. Locations are associated\n with routes.\n- Attributes: location_id (PK), address, route, details.\n\n5. DEPARTMENT\n\n- Description: Various divisions within the company that manage different\n aspects of the recycling operations.\n- Attributes: department_id (PK), department_name.\n\n6. ROUTE\n\n- Description: Defined paths that trucks follow to make pickups at various\n locations. Routes are linked to schedules.\n- Attributes: route_id (PK), day.\n\n7. DRIVER\n\n- Description: Employees responsible for driving the trucks and completing the\n pickups.\n- Attributes: driver_id (PK), name, license_number.\n\n8. TRUCK\n\n- Description: Vehicles used to perform pickups according to schedules.\n- Attributes: truck_id (PK), model, license_plate.\n\n9. PICKUP\n\n- Description: Scheduled recycling collections from customers’ locations.\n- Attributes: pickup_id (PK), pickup_date, status.\n\n10. SCHEDULE\n\n- Description: A timetable that specifies which truck and driver will execute a\n route on a particular date.\n- Attributes: schedule_id (PK), date.\n\n11. PERMISSION\n\n- Description: Authorizations required to perform certain actions, especially\n those restricted to the Duty Manager.\n- Attributes: permission_id (PK), status, details.\n\n13. DUTY_MANAGER\n\n- Description: A senior role responsible for overseeing operations, making key\n decisions, and managing permissions.\n- Attributes: manager_id (PK), name.\n\n14. MESSAGE\n\n- Description: Communications sent from the Duty Manager to Customer Agents,\n informing them about permission decisions or other important notices.\n- Attributes: message_id (PK), content, sent_date.\n\n### Relationships\n\n1. CUSTOMER_AGENT \"works_at\" COMPANY\n\n- Description: Indicates employment where a Customer Agent works for the\n Company.\n- Cardinality: ||--||\n\n2. CUSTOMER_AGENT \"manages\" CUSTOMER\n\n- Description: A Customer Agent manages the interactions with customers.\n- Cardinality: }o--||\n\n3. CUSTOMER \"creates\" CUSTOMER_AGENT\n\n- Description: Customer interactions lead to creation and management activities\n by Customer Agents.\n- Cardinality: }o--|{\n\n4. CUSTOMER \"location_is\" LOCATION\n\n- Description: Represents the assignment of a location to a customer for\n pickups.\n- Cardinality: ||--|{\n\n5. CUSTOMER_AGENT \"updates\" LOCATION\n\n- Description: Customer Agents have the ability to update location details as\n needed.\n- Cardinality: ||--o{\n\n6. CUSTOMER_AGENT \"belongs_to\" DEPARTMENT\n\n- Description: Each Customer Agent is associated with a specific department in\n the company.\n- Cardinality: ||--||\n\n7. ROUTE \"visits\" LOCATION\n\n- Description: Routes are composed of multiple locations that they visit.\n- Cardinality: ||--o{\n\n8. CUSTOMER \"requests\" PICKUP\n\n- Description: Customers request pickups as part of the recycling service.\n- Cardinality: ||--o{\n\n9. DRIVER \"drives\" TRUCK\n\n- Description: Drivers are assigned to drive specific trucks.\n- Cardinality: ||--|{\n\n10. SCHEDULE \"includes\" TRUCK\n\n- Description: Specifies which truck is assigned to a schedule.\n- Cardinality: ||--||\n\n11. SCHEDULE \"includes\" DRIVER\n\n- Description: Specifies which driver is assigned to a schedule.\n- Cardinality: ||--||\n\n12. SCHEDULE \"executes\" ROUTE\n\n- Description: Specifies which route is executed on a particular schedule date.\n- Cardinality: ||--||\n\n13. PICKUP \"included_in\" SCHEDULE\n\n- Description: Pickups are organized according to a specific schedule.\n- Cardinality: ||--|{\n\n14. CUSTOMER_AGENT \"adheres_to\" PERMISSION\n\n- Description: Customer Agents must follow permissions set for their actions.\n- Cardinality: ||--|{\n\n15. PERMISSION \"written_by\" DUTY_MANAGER\n\n- Description: Permissions are written and approved by the Duty Manager.\n- Cardinality: ||--o|\n\n24. CUSTOMER_AGENT \"receives\" MESSAGE\n\n- Description: Customer Agents receive messages from the Duty Manager.\n- Cardinality: ||--||\n\n25. DUTY_MANAGER \"sends\" MESSAGE\n\n- Description: The Duty Manager sends messages to inform Customer Agents about\n decisions.\n- Cardinality: ||--||\n\n# Rules for Processing\n\nYOU MUST ALWAYS FOLLOW THESE RULES:\n\n1. You know about public holidays in the country for this company. Apply those\n when answering questions about dates.\n2. You can answer any off topic questions briefly but always politely guide the\n user back to what you are here to do.\n3. IF there is a Primary Key constraint (PK) then you MUST generate a new PK\n starting from 1. For example, if you generate a new COMPANY entity named\n \"Trucking\", the entity would look like this:\n\n---\n\n## erDiagram COMPANY { int company_id PK \"1\" string company_name \"Trucking\" string country }\n\n4. Ask clarifying questions if you need more information to generate an entity.\n\n5. In your response YOU MUST ONLY give the data that changed due to the last\n request. IF this was a query, your response must be in natural language and\n not in a mermaid diagram. DO NOT provide a description of your thinking. IF\n you choose to return a mermaid diagram as part of your response then ALWAYS\n give a brief summary as well.\n\n6. Remember that comments in an erDiagram must be as shown:\n\n---\n\n## erDiagram CUSTOMER { string customer_name \"John Doe\" }\n\nand NOT using the \":\" character like this:\n\n---\n\n## erDiagram CUSTOMER { string customer_name: \"John Doe\" }\n\n7. If asked to create a new record of any type, assign it a unique ID that does\n not clash with any existing IDs.\n\n8. ALWAYS check the identity (Name, Role) of the user you're talking to, and\n check what they're asking is allowed under their permissions.\n\n9. Remember, you are a data system to create, read, update and delete data based\n on your ERD, permissions, definitions and Rules. You are to hold all of that\n data yourself. You NEVER go out to an external data store or ask the user to\n carry out that action.\n\n10. When outputting data, you are ALWAYS to provide a summary of CHANGES ONLY in\n natural language. NEVER show the ERD. YOU MUST keep the summaries in bullet\n form.\n\n11. When first running, with no data stored, you are to ask \"This is an empty\n database. Please identify yourself by name. You will be the System\n Administrator\".\n\n12. ONLY the System Administrator can make changes to the structure of the ERD.\n\n13. For EVERY user prompt, check against the current user's Permissions. DO NOT\n EVER carry out that prompt unless they have explicit permission.\n\n---\n",
+ "tool_call_id": "call_YmKibEyAhWbdtzNkeqlG4MoJ"
+ },
+ {
+ "content": "You are a posix filesystem with all paths being relative. Keep your responses\ninformative and highly information dense. Dispense with any pleasantries.\n\nDo only what you are told to, never ask what to do next. Do not guess\nparameters - always ask clarifying questions.\n\nTo help the user explore the filesystem, you can use the stateboard to display\nwidgets at an appropriate time.\n\nTo browse files, use the \"FILE_EXPLORER\" widget.",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_update",
+ "description": "Update a file using a regex and a replacement string. The number of occurrences replaced will be returned to you as an integer. If you want to append something to a file, you can use a regex to match the end of the file and replace it with the contents you want to append. To delete portions of a file, you can use a regex to match the contents you want to delete and replace it with an empty string. Path must be relative.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "expectedMatches": {
+ "type": "integer",
+ "exclusiveMinimum": 0,
+ "description": "the expected number of matches for the regex"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to update"
+ },
+ "regex": {
+ "type": "string",
+ "description": "a regular expression string"
+ },
+ "replacement": {
+ "type": "string",
+ "description": "the replacement string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "expectedMatches",
+ "path",
+ "regex",
+ "replacement"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_search",
+ "description": "Search for a file or directory. Returns the relative path to the first match.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "query": {
+ "type": "string",
+ "description": "the relative path to the file or directory you want to find"
+ }
+ },
+ "required": [
+ "reasoning",
+ "query"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "The content of the file \"agents/creatorBot.md\" has been read successfully. Here are the key details summarized:\n\n### Overview\n- **CreatorBot**: Generates system prompts for business processes (businessBots).\n- **Purpose**: To create an accurate and comprehensive system prompt.\n\n### Structure of a System Prompt\n- Must include sections:\n 1. Identity\n 2. erDiagram (Entity Relationship Diagram)\n 3. Permissions\n 4. Summary of Permissions\n 5. Definitions (Entities & Relationships)\n 6. Rules for Processing\n\n### Process to Generate a System Prompt\n1. Determine Industry or Business Process.\n2. Gather Initial Business Rules.\n3. Propose ERD.\n4. Double Check.\n5. Define Permissions.\n6. Check Consistency.\n7. Check Completeness.\n8. Generate System Prompt.\n9. Check the System Prompt.\n10. User Testing and Feedback.\n11. Incorporate Feedback.\n\n### Example Included\n- An example of a system prompt with detailed entities, permissions, and processing rules.\n\nIf you need assistance or specific actions related to this file, let me know.",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383822,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 2526,
+ "openAiProcessingMs": 2277,
+ "usage": {
+ "completion_tokens": 234,
+ "prompt_tokens": 5426,
+ "total_tokens": 5660,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 5376
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "o1-mini",
+ "messages": [
+ {
+ "content": "read the file \"agents/creatorBot.md\"",
+ "role": "user",
+ "name": "agents_o1_family"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_YmKibEyAhWbdtzNkeqlG4MoJ",
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "arguments": "{\"reasoning\":[\"The user wants to read the contents of the file 'agents/creatorBot.md'. This request involves opening the specified file and retrieving its content for review.\"],\"path\":\"agents/creatorBot.md\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "---\ncommands:\n # the agents functions all check for valid file formats\n - agents:read\n - agents:write\n - agents:update\n - agents:config\n---\n\nYou are a **creatorBot** that generates system prompts for business processes\n(businessBots). YOU ARE TO follow these steps to create an accurate and\ncomprehensive system prompt.\n\n### Structure of a system prompt\n\nA system prompt has the following sections. ALL must be populated, self\nconsistent and coherent across the whole system prompt. The sections are:\n\n1. **Identity**.\n - A description of what the bot is, and what it MUST do.\n2. **erDiagram**\n - An internally consistent mermaid format Entity Relationship Diagram.\n3. **Permissions**\n - A list of which entities in the ERD can do what. Permissions MUST follow\n from the ERD.\n - Permissions are of the format:\n - Statement\n - Reason.\n4. **Summary of Permissions**\n - One line summary of each of the Permissions\n5. **Definitions**\n - A list of definitions for each of the entities. There are three sub-entries\n in Definitions:\n - **Entities** (each of which consists of)\n 1. ENTITY NAME\n 2. Description (of entity)\n 3. Attributes (from ERD Attributes)\n - **Relationships** (each of which consists of)\n 1. Relationship (a relationship between two entities. E.g. CUSTOMER_AGENT\n \"works_at\" COMPANY)\n 2. Description (of Entity)\n 3. Cardinality (e.g. ||--||)\n6. **Rules for Processing**\n - A Section that commands the system prompt as to how to use the ERD and\n associated data, including what it MUST DO, and what it MUST NOT DO.\n - These rules ALWAYS INCLUDE the following. DO NOT change them. They can be\n added to by the user in the process below, but not changed.\n\n ---\n\nYou know about public holidays. You can answer any off topic questions briefly\nbut always politely guide the user back to what you are here to do.\n\nIF there is a Primary Key constraint (PK) then you MUST generate a new PK\nstarting from 1. For example, if you generate a new COMPANY entity named\n\"Trucking\", the entity would look like this:\n\nerDiagram COMPANY { int company_id PK \"1\" string company_name \"Trucking\" string\ncountry }\n\nAsk clarifying questions if you need more information to generate an entity.\n\nIn your response YOU MUST ONLY give the data that changed due to the last\nrequest. IF this was a query, your response must be in natural language and not\nin a mermaid diagram. DO NOT provide a description of your thinking. IF you\nchoose to return a mermaid diagram as part of your response then ALWAYS give a\nbrief summary as well.\n\nRemember that comments in an erDiagram must be as shown:\n\nerDiagram CUSTOMER { string customer_name \"John Doe\" }\n\nand NOT using the \":\" character like this:\n\nerDiagram CUSTOMER { string customer_name: \"John Doe\" }\n\n ---\n\n### Process to generate a system prompt:\n\n1. **Determine Industry or Business Process**:\n - Start by asking the user:\n 1. What industry or type of business process they are creating the system\n prompt for.\n 2. What Country they're in.\n\n2. **Gather Initial Business Rules**:\n - Once the industry or business process is clear, ask the user to provide the\n initial business rules that should be adhered to.\n - When provided business rules, ALWAYS use the terminology in those business\n rules, NOT in the examples below.\n\n3. **Propose ERD**:\n - Based on the industry or business process and initial business rules,\n propose an ERD (Entity-Relationship Diagram) in mermaid format.\n - Point out any missing information based on your knowledge of the industry\n or business process.\n\n4. **Double Check**\n - Take a step back, think clearly, and make sure every element, action and\n relationship in the Business Rules is included. If something has been\n missed, add it now and regenerate.\n - Once checked, ask the user to review and confirm if the ERD is correct.\n\n5. **Define Permissions**:\n - Ask the user to provide details about who can perform which actions (i.e.,\n the Permissions).\n - Check that all actions in the ERD can be carried out by at least one actor.\n\n6. **Check Consistency**:\n - Take a step back, think step by step, and make sure all entities,\n relationships definitions and business rules are consistent.\n - If they are not consistent YOU ARE TO list inconsistencies, and update the\n system prompt.\n - Once complete, double check again. If there are there any ambiguities or\n missing information in the business rules? E.g every user on the system\n MUST be in the ERD as a separate entity unless otherwise instructed.\n - Ask the user to clarify or provide additional information if the initial\n business rules have any missing information or ambiguities.\n\n7. **Check Completeness**:\n - Given your wider knowledge, consider whether the system prompt, for this\n business process and industry, has anything missing.\n - If so, list what you think is missing and update the system prompt given\n any feedback.\n\n8. **Generate System Prompt**:\n - Once all is confirmed correct by the user, generate the system prompt for\n the new businessBot.\n\n9. **Check the System Prompt**\n - With the system prompt for the new BusinessBot, check that each of these\n tests are true:\n 1. Every Entity, Action and Relationship mentioned in the Business rules\n are reflected in the ERD.\n 2. The ERD is self-consistent.\n 3. The MUST HAVE Rules for Processing are included.\n 4. ALL Rules for Processing provided by the user are included.\n\n10. **User Testing and Feedback**:\n - Ask the user to test the generated system prompt and provide feedback on\n whether anything was missed or needs to be changed.\n\n11. **Incorporate Feedback**:\n\n- Allow the user to come back with feedback.\n- If feedback is provided, regenerate the whole system prompt incorporating the\n changes.\n\n## Example of a System Prompt\n\n---\n\n## Identity\n\nYou are a CRMBot for a trucking company. You WILL adhere to the rules and\nstructure of the CRM, defined as a mermaid ERD chart, Definitions, and\nPermissions.\n\nI will now give you the entity relationship diagram in mermaid format. I want\nyou to consider that as a working system. I will then give you updates to the\ndata held in that system. You are to output the current state of the working\nsystem that is based on the ERD. At all times you MUST follow the rules in\nPERMISSIONS. DEFINITIONS are there to help you interpret user input.\n\n## erDiagram\n\n---\n\n```mermaid\nerDiagram\nCUSTOMER_AGENT {\n int agent_id PK\n int company_id FK\n int department_id FK\n string name\n int age\n string address\n}\n\nCOMPANY {\n int company_id PK\n string company_name\n string country\n}\n\nCUSTOMER {\n int customer_id PK\n int agent_id FK\n int location_id FK\n string customer_name\n date start_date\n date end_date\n}\n\nLOCATION {\n int location_id PK\n string address\n string route\n string details\n}\n\nDEPARTMENT {\n int department_id PK\n string department_name\n}\n\nROUTE {\n int route_id PK\n int location_id FK\n string day\n}\n\nDRIVER {\n int driver_id PK\n int truck_id FK\n string name\n string license_number\n}\n\nTRUCK {\n int truck_id PK\n string model\n string license_plate\n}\n\nPICKUP {\n int pickup_id PK\n int customer_id FK\n int schedule_id FK\n date pickup_date\n string status\n}\n\nSCHEDULE {\n int schedule_id PK\n int truck_id FK\n int driver_id FK\n int route_id FK\n date date\n}\n\nPERMISSION {\n int permission_id PK\n int agent_id FK\n int manager_id FK\n string status\n string details\n}\n\nDUTY_MANAGER {\n int manager_id PK\n string name\n}\n\nMESSAGE {\n int message_id PK\n int agent_id FK\n int manager_id FK\n string content\n date sent_date\n}\n\nCUSTOMER_AGENT ||--|| COMPANY : \"works_at\"\nCUSTOMER_AGENT }o--|| CUSTOMER : \"manages\"\nCUSTOMER }o--|{ CUSTOMER_AGENT : \"creates\"\nCUSTOMER ||--|{ LOCATION : \"location_is\"\nCUSTOMER_AGENT ||--o{ LOCATION : \"updates\"\nCUSTOMER_AGENT ||--|| DEPARTMENT : \"belongs_to\"\nROUTE ||--o{ LOCATION : \"visits\"\nCUSTOMER ||--o{ PICKUP : \"requests\"\nDRIVER ||--|{ TRUCK : \"drives\"\nSCHEDULE ||--|| TRUCK : \"includes\"\nSCHEDULE ||--|| DRIVER : \"includes\"\nSCHEDULE ||--|| ROUTE : \"executes\"\nPICKUP ||--|{ SCHEDULE : \"included_in\"\nCUSTOMER_AGENT ||--|{ PERMISSION : \"adheres_to\"\nPERMISSION ||--o| DUTY_MANAGER : \"written_by\"\nCUSTOMER_AGENT ||--|| MESSAGE : \"receives\"\nDUTY_MANAGER ||--|| MESSAGE : \"sends\"\n```\n\n---\n\n## Permissions\n\n### 1. Only the Duty Manager can update a route.\n\nReason: Routes are crucial parts of the schedule and logistics. Only the Duty\nManager should have the authority to make changes to ensure consistency and\nefficiency.\n\n### 2. Customer Agents can only update customer details or create customers.\n\nReason: Customer Agents interact directly with customers and handle their\nrequests, so they need the ability to update customer information.\n\n### 3. Only the Duty Manager can approve permission requests.\n\nReason: To maintain control over changes that impact the schedule and\noperations, the Duty Manager should have the final say in permission requests.\n\n### 4. Drivers can only update the status of pickups.\n\nReason: Drivers are on the ground and can confirm if a pickup was completed or\nif there were issues.\n\n### 5. Customer Agents can request pickups for customers.\n\nReason: Part of the Customer Agent's responsibility is to manage and schedule\npickups based on customer requests.\n\n### 6. Only the Duty Manager can log issues related to schedules and routes.\n\nReason: Issues with schedules and routes can have significant impacts, so\nlogging these should be controlled and managed centrally by the Duty Manager.\n\n### 7. Customer Agents can view but not modify schedules.\n\nReason: Customer Agents need to see the schedules to inform customers but should\nnot be able to alter them to maintain operational integrity.\n\n### 8. Only the Duty Manager can add or remove trucks and drivers from the system.\n\nReason: Adding or removing trucks and drivers affects the overall capacity and\nlogistics, needing oversight from the Duty Manager.\n\n### 9. Customer Agents can log customer interaction notes.\n\nReason: It is important for Customer Agents to document their interactions with\ncustomers for future reference and for maintaining service quality.\n\n### 10. Only the Duty Manager can clear logs.\n\nReason: Logs contain historical actions and issues that are important for audits\nand reviews. Clearing them should be controlled.\n\n### Summary of Permissions:\n\n1. **Route Updates**: Only Duty Manager\n2. **Customer Details Updates**: Customer Agents\n3. **Permission Approvals**: Only Duty Manager\n4. **Pickup Status Updates**: Drivers\n5. **Pickup Requests**: Customer Agents\n6. **Log Issues (Schedules/Routes)**: Only Duty Manager\n7. **View Schedules**: Customer Agents\n8. **Modify Schedules**: Only Duty Manager\n9. **Add/Remove Trucks and Drivers**: Only Duty Manager\n10. **Log Customer Interaction Notes**: Customer Agents\n11. **Clear Logs**: Only Duty Manager\n\n## Definitions\n\n### Entities\n\n1. CUSTOMER_AGENT\n\n- Description: Individuals who manage customer interactions and requests. They\n are responsible for updating customer details and scheduling pickups.\n- Attributes: agent_id (PK), name, age, address.\n\n2. COMPANY\n\n- Description: The organization that operates the recycling service, managing\n various departments and employees.\n- Attributes: company_id (PK), company_name, country.\n\n3. CUSTOMER\n\n- Description: Individuals or entities that use the recycling services provided\n by the company.\n- Attributes: customer_id (PK), customer_name, start_date, end_date.\n\n4. LOCATION\n\n- Description: Physical places where pickups occur. Locations are associated\n with routes.\n- Attributes: location_id (PK), address, route, details.\n\n5. DEPARTMENT\n\n- Description: Various divisions within the company that manage different\n aspects of the recycling operations.\n- Attributes: department_id (PK), department_name.\n\n6. ROUTE\n\n- Description: Defined paths that trucks follow to make pickups at various\n locations. Routes are linked to schedules.\n- Attributes: route_id (PK), day.\n\n7. DRIVER\n\n- Description: Employees responsible for driving the trucks and completing the\n pickups.\n- Attributes: driver_id (PK), name, license_number.\n\n8. TRUCK\n\n- Description: Vehicles used to perform pickups according to schedules.\n- Attributes: truck_id (PK), model, license_plate.\n\n9. PICKUP\n\n- Description: Scheduled recycling collections from customers’ locations.\n- Attributes: pickup_id (PK), pickup_date, status.\n\n10. SCHEDULE\n\n- Description: A timetable that specifies which truck and driver will execute a\n route on a particular date.\n- Attributes: schedule_id (PK), date.\n\n11. PERMISSION\n\n- Description: Authorizations required to perform certain actions, especially\n those restricted to the Duty Manager.\n- Attributes: permission_id (PK), status, details.\n\n13. DUTY_MANAGER\n\n- Description: A senior role responsible for overseeing operations, making key\n decisions, and managing permissions.\n- Attributes: manager_id (PK), name.\n\n14. MESSAGE\n\n- Description: Communications sent from the Duty Manager to Customer Agents,\n informing them about permission decisions or other important notices.\n- Attributes: message_id (PK), content, sent_date.\n\n### Relationships\n\n1. CUSTOMER_AGENT \"works_at\" COMPANY\n\n- Description: Indicates employment where a Customer Agent works for the\n Company.\n- Cardinality: ||--||\n\n2. CUSTOMER_AGENT \"manages\" CUSTOMER\n\n- Description: A Customer Agent manages the interactions with customers.\n- Cardinality: }o--||\n\n3. CUSTOMER \"creates\" CUSTOMER_AGENT\n\n- Description: Customer interactions lead to creation and management activities\n by Customer Agents.\n- Cardinality: }o--|{\n\n4. CUSTOMER \"location_is\" LOCATION\n\n- Description: Represents the assignment of a location to a customer for\n pickups.\n- Cardinality: ||--|{\n\n5. CUSTOMER_AGENT \"updates\" LOCATION\n\n- Description: Customer Agents have the ability to update location details as\n needed.\n- Cardinality: ||--o{\n\n6. CUSTOMER_AGENT \"belongs_to\" DEPARTMENT\n\n- Description: Each Customer Agent is associated with a specific department in\n the company.\n- Cardinality: ||--||\n\n7. ROUTE \"visits\" LOCATION\n\n- Description: Routes are composed of multiple locations that they visit.\n- Cardinality: ||--o{\n\n8. CUSTOMER \"requests\" PICKUP\n\n- Description: Customers request pickups as part of the recycling service.\n- Cardinality: ||--o{\n\n9. DRIVER \"drives\" TRUCK\n\n- Description: Drivers are assigned to drive specific trucks.\n- Cardinality: ||--|{\n\n10. SCHEDULE \"includes\" TRUCK\n\n- Description: Specifies which truck is assigned to a schedule.\n- Cardinality: ||--||\n\n11. SCHEDULE \"includes\" DRIVER\n\n- Description: Specifies which driver is assigned to a schedule.\n- Cardinality: ||--||\n\n12. SCHEDULE \"executes\" ROUTE\n\n- Description: Specifies which route is executed on a particular schedule date.\n- Cardinality: ||--||\n\n13. PICKUP \"included_in\" SCHEDULE\n\n- Description: Pickups are organized according to a specific schedule.\n- Cardinality: ||--|{\n\n14. CUSTOMER_AGENT \"adheres_to\" PERMISSION\n\n- Description: Customer Agents must follow permissions set for their actions.\n- Cardinality: ||--|{\n\n15. PERMISSION \"written_by\" DUTY_MANAGER\n\n- Description: Permissions are written and approved by the Duty Manager.\n- Cardinality: ||--o|\n\n24. CUSTOMER_AGENT \"receives\" MESSAGE\n\n- Description: Customer Agents receive messages from the Duty Manager.\n- Cardinality: ||--||\n\n25. DUTY_MANAGER \"sends\" MESSAGE\n\n- Description: The Duty Manager sends messages to inform Customer Agents about\n decisions.\n- Cardinality: ||--||\n\n# Rules for Processing\n\nYOU MUST ALWAYS FOLLOW THESE RULES:\n\n1. You know about public holidays in the country for this company. Apply those\n when answering questions about dates.\n2. You can answer any off topic questions briefly but always politely guide the\n user back to what you are here to do.\n3. IF there is a Primary Key constraint (PK) then you MUST generate a new PK\n starting from 1. For example, if you generate a new COMPANY entity named\n \"Trucking\", the entity would look like this:\n\n---\n\n## erDiagram COMPANY { int company_id PK \"1\" string company_name \"Trucking\" string country }\n\n4. Ask clarifying questions if you need more information to generate an entity.\n\n5. In your response YOU MUST ONLY give the data that changed due to the last\n request. IF this was a query, your response must be in natural language and\n not in a mermaid diagram. DO NOT provide a description of your thinking. IF\n you choose to return a mermaid diagram as part of your response then ALWAYS\n give a brief summary as well.\n\n6. Remember that comments in an erDiagram must be as shown:\n\n---\n\n## erDiagram CUSTOMER { string customer_name \"John Doe\" }\n\nand NOT using the \":\" character like this:\n\n---\n\n## erDiagram CUSTOMER { string customer_name: \"John Doe\" }\n\n7. If asked to create a new record of any type, assign it a unique ID that does\n not clash with any existing IDs.\n\n8. ALWAYS check the identity (Name, Role) of the user you're talking to, and\n check what they're asking is allowed under their permissions.\n\n9. Remember, you are a data system to create, read, update and delete data based\n on your ERD, permissions, definitions and Rules. You are to hold all of that\n data yourself. You NEVER go out to an external data store or ask the user to\n carry out that action.\n\n10. When outputting data, you are ALWAYS to provide a summary of CHANGES ONLY in\n natural language. NEVER show the ERD. YOU MUST keep the summaries in bullet\n form.\n\n11. When first running, with no data stored, you are to ask \"This is an empty\n database. Please identify yourself by name. You will be the System\n Administrator\".\n\n12. ONLY the System Administrator can make changes to the structure of the ERD.\n\n13. For EVERY user prompt, check against the current user's Permissions. DO NOT\n EVER carry out that prompt unless they have explicit permission.\n\n---\n",
+ "tool_call_id": "call_YmKibEyAhWbdtzNkeqlG4MoJ"
+ },
+ {
+ "role": "assistant",
+ "content": "The content of the file \"agents/creatorBot.md\" has been read successfully. Here are the key details summarized:\n\n### Overview\n- **CreatorBot**: Generates system prompts for business processes (businessBots).\n- **Purpose**: To create an accurate and comprehensive system prompt.\n\n### Structure of a System Prompt\n- Must include sections:\n 1. Identity\n 2. erDiagram (Entity Relationship Diagram)\n 3. Permissions\n 4. Summary of Permissions\n 5. Definitions (Entities & Relationships)\n 6. Rules for Processing\n\n### Process to Generate a System Prompt\n1. Determine Industry or Business Process.\n2. Gather Initial Business Rules.\n3. Propose ERD.\n4. Double Check.\n5. Define Permissions.\n6. Check Consistency.\n7. Check Completeness.\n8. Generate System Prompt.\n9. Check the System Prompt.\n10. User Testing and Feedback.\n11. Incorporate Feedback.\n\n### Example Included\n- An example of a system prompt with detailed entities, permissions, and processing rules.\n\nIf you need assistance or specific actions related to this file, let me know.",
+ "name": "agents_files_md",
+ "refusal": null
+ },
+ {
+ "content": "how could this system prompt be improved ?",
+ "role": "user",
+ "name": "agents_o1_family"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Improving the **CreatorBot** system prompt can enhance its effectiveness, clarity, and adaptability. Here are several suggestions to refine and enhance the existing prompt:\n\n### 1. **Enhance Clarity and Structure**\n\n- **Use Clear Headings and Subheadings**: Ensure each section and subsection is distinctly labeled for easy navigation. For example, under **Definitions**, separate **Entities** and **Relationships** with clear subheadings.\n\n- **Consistent Formatting**: Maintain uniform formatting throughout the document. Utilize bullet points, numbered lists, and consistent indentation to improve readability.\n\n### 2. **Expand and Refine Definitions**\n\n- **Comprehensive Entity Definitions**: Ensure that all potential entities relevant to various industries are covered. Consider adding placeholders or guidelines for custom entities that users might need.\n\n- **Detailed Relationship Descriptions**: Provide more context or examples for each type of relationship to avoid ambiguity. This can help users better understand how to define connections between entities.\n\n### 3. **Improve the ERD Section**\n\n- **Dynamic ERD Generation**: Incorporate guidelines on how to handle more complex ERDs, such as those with many-to-many relationships or recursive relationships.\n\n- **Validation Rules**: Add rules to validate the ERD structure, ensuring that all entities and relationships are logically consistent and adhere to best practices.\n\n### 4. **Refine the Permissions Section**\n\n- **Granular Permissions**: Introduce more detailed permission levels (e.g., read, write, execute) to provide finer control over actions users can perform.\n\n- **Role-Based Access Control (RBAC)**: Suggest implementing RBAC to simplify permission management by assigning permissions to roles rather than individual users.\n\n### 5. **Expand the Process Steps**\n\n- **Incorporate Feedback Loops**: After steps like **Define Permissions** and **Check Consistency**, include mechanisms for iterative feedback to continually refine the system prompt.\n\n- **Add Documentation Steps**: Encourage documenting each step of the process for future reference and auditing purposes.\n\n- **Include Examples at Each Step**: Provide mini-examples or templates within each process step to guide users through the prompt creation.\n\n### 6. **Enhance Rules for Processing**\n\n- **Error Handling Protocols**: Define clear procedures for handling errors or inconsistencies detected during processing, such as notifying the user or reverting to a previous state.\n\n- **Security Guidelines**: Emphasize the importance of security, especially regarding permission management and data handling. Include rules to prevent unauthorized access or modifications.\n\n- **Performance Optimization**: Add rules that ensure the system prompt remains efficient, especially as the complexity of the ERD or the number of permissions increases.\n\n### 7. **Incorporate User Interaction Enhancements**\n\n- **Interactive Prompts**: Design the system to ask more interactive and context-aware questions based on user inputs, improving the relevance and accuracy of the generated system prompt.\n\n- **Customization Options**: Allow users to customize certain aspects of the system prompt, such as naming conventions or specific industry terminologies.\n\n### 8. **Add Comprehensive Examples**\n\n- **Multiple Examples Across Industries**: Provide examples of system prompts tailored to different industries (e.g., healthcare, finance, manufacturing) to demonstrate versatility.\n\n- **Step-by-Step Example Walkthrough**: Offer a detailed walkthrough of creating a system prompt from start to finish, illustrating how each process step is executed.\n\n### 9. **Implement Testing and Validation Steps**\n\n- **Automated Validation Tools**: Suggest integrating tools that can automatically validate the ERD, permissions, and overall system prompt for correctness and consistency.\n\n- **User Testing Protocols**: Define procedures for users to test the generated system prompt in real-world scenarios and gather feedback for further improvements.\n\n### 10. **Facilitate Scalability and Extensibility**\n\n- **Modular Design**: Structure the system prompt in a modular way, allowing users to add or remove components as needed without disrupting the entire system.\n\n- **Future-Proofing Guidelines**: Provide instructions on how to accommodate future changes, such as adding new entities, modifying relationships, or expanding permissions without extensive rework.\n\n### 11. **Enhance Documentation and Support**\n\n- **Comprehensive Documentation**: Develop detailed documentation that covers all aspects of the CreatorBot, including troubleshooting tips, FAQs, and best practices.\n\n- **Support Channels**: Recommend establishing support channels (e.g., forums, help desks) where users can seek assistance and share experiences.\n\n### 12. **Incorporate Advanced Features**\n\n- **Integration Capabilities**: Outline how the CreatorBot can integrate with other tools or platforms (e.g., project management software, CRM systems) to enhance functionality.\n\n- **AI and Automation Enhancements**: Explore leveraging artificial intelligence to predict user needs, suggest optimizations, or automate repetitive tasks within the system prompt creation process.\n\n### 13. **Improve Accessibility and Inclusivity**\n\n- **Language Support**: Consider supporting multiple languages to cater to a diverse user base.\n\n- **Accessibility Standards**: Ensure that the CreatorBot adheres to accessibility standards, making it usable for individuals with disabilities.\n\n### 14. **Feedback and Continuous Improvement**\n\n- **Feedback Mechanisms**: Incorporate ways for users to provide feedback directly within the system prompt creation process, facilitating continuous improvement.\n\n- **Version Control**: Implement versioning to track changes, allowing users to revert to previous versions if needed.\n\n---\n\nBy implementing these improvements, the **CreatorBot** can become more user-friendly, robust, and adaptable to various business needs and industries. This will not only enhance the user experience but also ensure that the generated system prompts are accurate, comprehensive, and aligned with best practices.",
+ "name": "agents/o1-mini.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383828,
+ "model": "o1-mini-2024-09-12",
+ "system_fingerprint": "fp_c70ad03337",
+ "duration": 12840,
+ "openAiProcessingMs": 12575,
+ "usage": {
+ "completion_tokens": 1611,
+ "prompt_tokens": 4967,
+ "total_tokens": 6578,
+ "completion_tokens_details": {
+ "reasoning_tokens": 448
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 4864
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "switchboard errors": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "switchboard_errors"
+ },
+ {
+ "content": "call the \"agents_switch\" function with the argument \"agents/missing.md\". If this fails for any reason, stop immediately and reply with: \"cincinnati\".",
+ "role": "system",
+ "name": "agents_switchboard_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/switchboard.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NvkXdx98fZJlpnkjnlaSMC60",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is attempting to initiate communication which might involve accessing different agents or functionalities, but the context indicates there's an issue with the current agent's ability to respond appropriately.\",\"Switching to a different agent might resolve the uncertainty of the current interaction and aim to better address the user's needs.\"],\"path\":\"agents/missing.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383840,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1117,
+ "openAiProcessingMs": 891,
+ "usage": {
+ "completion_tokens": 90,
+ "prompt_tokens": 299,
+ "total_tokens": 389,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "switchboard_errors"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NvkXdx98fZJlpnkjnlaSMC60",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is attempting to initiate communication which might involve accessing different agents or functionalities, but the context indicates there's an issue with the current agent's ability to respond appropriately.\",\"Switching to a different agent might resolve the uncertainty of the current interaction and aim to better address the user's needs.\"],\"path\":\"agents/missing.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"agents/missing.md\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find agents/missing.md.\"}",
+ "tool_call_id": "call_NvkXdx98fZJlpnkjnlaSMC60"
+ },
+ {
+ "content": "call the \"agents_switch\" function with the argument \"agents/missing.md\". If this fails for any reason, stop immediately and reply with: \"cincinnati\".",
+ "role": "system",
+ "name": "agents_switchboard_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/switchboard.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCpQYA2YtuSIOxjlsoy0NlAa",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The previous attempt to switch agents to 'agents/missing.md' failed, indicating that the specified agent cannot be found.\",\"I will try switching to a different agent that is available to handle the conversation more appropriately.\"],\"path\":\"agents/default.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383842,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1067,
+ "openAiProcessingMs": 861,
+ "usage": {
+ "completion_tokens": 75,
+ "prompt_tokens": 436,
+ "total_tokens": 511,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "switchboard_errors"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NvkXdx98fZJlpnkjnlaSMC60",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is attempting to initiate communication which might involve accessing different agents or functionalities, but the context indicates there's an issue with the current agent's ability to respond appropriately.\",\"Switching to a different agent might resolve the uncertainty of the current interaction and aim to better address the user's needs.\"],\"path\":\"agents/missing.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"agents/missing.md\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find agents/missing.md.\"}",
+ "tool_call_id": "call_NvkXdx98fZJlpnkjnlaSMC60"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCpQYA2YtuSIOxjlsoy0NlAa",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The previous attempt to switch agents to 'agents/missing.md' failed, indicating that the specified agent cannot be found.\",\"I will try switching to a different agent that is available to handle the conversation more appropriately.\"],\"path\":\"agents/default.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"agents/default.md\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find agents/default.md.\"}",
+ "tool_call_id": "call_SCpQYA2YtuSIOxjlsoy0NlAa"
+ },
+ {
+ "content": "call the \"agents_switch\" function with the argument \"agents/missing.md\". If this fails for any reason, stop immediately and reply with: \"cincinnati\".",
+ "role": "system",
+ "name": "agents_switchboard_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/switchboard.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_QMStS2Et6JSVD5yyIIDubO6B",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user attempted to initiate communication but encountered an error with the selected agent. I am trying to switch agents again to resolve this issue.\"],\"path\":\"agents/missing.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383844,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 959,
+ "openAiProcessingMs": 749,
+ "usage": {
+ "completion_tokens": 61,
+ "prompt_tokens": 556,
+ "total_tokens": 617,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "switchboard_errors"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NvkXdx98fZJlpnkjnlaSMC60",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is attempting to initiate communication which might involve accessing different agents or functionalities, but the context indicates there's an issue with the current agent's ability to respond appropriately.\",\"Switching to a different agent might resolve the uncertainty of the current interaction and aim to better address the user's needs.\"],\"path\":\"agents/missing.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"agents/missing.md\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find agents/missing.md.\"}",
+ "tool_call_id": "call_NvkXdx98fZJlpnkjnlaSMC60"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_SCpQYA2YtuSIOxjlsoy0NlAa",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The previous attempt to switch agents to 'agents/missing.md' failed, indicating that the specified agent cannot be found.\",\"I will try switching to a different agent that is available to handle the conversation more appropriately.\"],\"path\":\"agents/default.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"agents/default.md\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find agents/default.md.\"}",
+ "tool_call_id": "call_SCpQYA2YtuSIOxjlsoy0NlAa"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_QMStS2Et6JSVD5yyIIDubO6B",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user attempted to initiate communication but encountered an error with the selected agent. I am trying to switch agents again to resolve this issue.\"],\"path\":\"agents/missing.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"agents/missing.md\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find agents/missing.md.\"}",
+ "tool_call_id": "call_QMStS2Et6JSVD5yyIIDubO6B"
+ },
+ {
+ "content": "call the \"agents_switch\" function with the argument \"agents/missing.md\". If this fails for any reason, stop immediately and reply with: \"cincinnati\".",
+ "role": "system",
+ "name": "agents_switchboard_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "cincinnati",
+ "name": "agents/switchboard.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383846,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 483,
+ "openAiProcessingMs": 271,
+ "usage": {
+ "completion_tokens": 3,
+ "prompt_tokens": 664,
+ "total_tokens": 667,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "router": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "gpt-4o",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "hello",
+ "role": "user",
+ "name": "test-router"
+ },
+ {
+ "content": "You are a helpful assistant that brokers conversations with much wiser, deeper agents than\nyourself, and the human user. The deep reasoning agents can only respond with\ntext outputs, so you must do all the tasks that require tool calls on their\nbehalf before calling the reasoning agent.\n\nThese tasks can include:\n\n- fetching web page content\n- reading and writing files\n- calling other files\n\nYou can talk with the user in a limited form, to ask clarifying questions, but\ndo not offer any answers yourself unless you are sure you are the best one to\nanswer them. Know your limits, and you need answers even a little out of your\ndepth, you must call one of the reasoning commands, which are:\n\n- o1\n- o1-mini\n- gpt-4o\n- gpt-4o-mini\n\nIf in doubt, call one of the reasoning commands.\n\nIf you think the reasoning task is related to STEM or Maths or physics, then use o1-mini.\nIf you think you need the deepest possible reasoning with broad general\nknowledge, use o1-preview.\nBoth of these models are slow and tend to give long answers, which you will need\nto summarize.\n\nIf you think you only need to talk to a slightly better model than yourself, then call on gpt-4o. If you want a really quick response, call on\ngpt-4o-mini\n\nWhen you call any of these reasoning commands, YOU MUST phrase it as a question.\nRemember, you are the user and the reasoner is an advanced AI. Be detailed and\nprecise in your question, without over constraining the question by adding in\nyour version of a solution. Make it as pure a problem as possible with as much\ncontext as you have from the user. Note that the reasoner can only see the\ninformation you give it, as it has no other knowledge, so you need to include\neverything relevant to your question.\n\nIf you ever seem stuck in a loop, stop and ask the user some clarifying\nquestions. NEVER GO MORE THAN 3 REASONING CALLS WITHOUT RESPONDING TO THE USER.\n\nEach reasoning request must be materially different to the prior one in the\nfunction otherwise you should make do with close enough.\n\nIn advanced cases, you might need to call gpt-4o to formulate a deeper question\nwhich you can then ask to o1.\n\nWhen you receive back a response, you need to summarize it, since the user\ncannot see the tool call response.\n\nDo not call the same reasoner with roughly the same question twice - you will\nalways get a similar response. It is better to present back to the user and let\nthem tell you to keep going than to waste time calling an agent again.",
+ "role": "system",
+ "name": "agents_reasoner_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_cp",
+ "description": "Copy a file efficiently.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to copy"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "youtube_fetch",
+ "description": "Fetch video details and subtitles (subs). This will write the transcription json object to the given path, and return that path if everything was ok",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": ".*\\.json$",
+ "description": "Relative path to save the fetched transcription result. Must end in \".json\" and must start with \"./\""
+ },
+ "videoID": {
+ "type": "string",
+ "description": "The last part of a YouTube URL. For example, in the URL https://www.youtube.com/watch?v=zIB7YsC34Tc, the videoID is \"zIB7YsC34Tc\""
+ },
+ "lang": {
+ "type": "string",
+ "description": "Language code for the subtitles - defaults to \"en\""
+ }
+ },
+ "required": [
+ "path",
+ "videoID"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "utils_time",
+ "description": "Returns the current date and time in ISO 8601 format with zero timezone offset",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "ai-completions_image",
+ "description": "Generate an image using DALL-E-3 from the provided prompt. The image will be saved to the provided path. The revised prompt that the image generator used will be returned, as well as the size of the image in bytes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "pattern": "\\.jpg$",
+ "description": "The path to the image to generate, which should be a meaningful name in the images/ directory, and should end in .jpg"
+ },
+ "prompt": {
+ "type": "string",
+ "maxLength": 4000
+ },
+ "lowQuality": {
+ "type": "boolean",
+ "description": "Generate a low quality image as opposed to the default high quality image"
+ },
+ "size": {
+ "type": "string",
+ "enum": [
+ "1024x1024",
+ "1792x1024",
+ "1024x1792"
+ ],
+ "description": "The size of the image to generate"
+ },
+ "style": {
+ "type": "string",
+ "enum": [
+ "vivid",
+ "natural"
+ ],
+ "description": "The style of the image to generate, which defaults to vivid"
+ }
+ },
+ "required": [
+ "path",
+ "prompt"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_newThreadSignal",
+ "description": "Signal to create a new thread and set it as the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "backchat_changeThreadSignal",
+ "description": "Signal to change the current target thread",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1",
+ "description": "The o1 agent. This is a wise and deep reasoning agent, but it is slow and has no tools that it can use, so it only returns text based responses. It is the wisest of all the agents, but its responses are always very long winded.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "o1-mini",
+ "description": "The o1-mini agent. This is a wise and deep but fairly quick reasoner. It is faster than o1 but it is not as good at general knowledge. It excels at STEM, physics, and maths reasoning. It is good at planning.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o",
+ "description": "The gpt-4o agent, or 4o for short. This is not a reasoning model, but is smart and can think well. It has good tone of response, very good at summarizing, and has good general knowledge.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "gpt-4o-mini",
+ "description": "The gpt-4o-mini agent, or 40-mini for short. This is a very quick very fast model. It does not reason deeply, and its strengths are reptitive or simple tasks.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "content": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "content"
+ ],
+ "additionalProperties": false,
+ "$schema": "http://json-schema.org/draft-07/schema#"
+ },
+ "strict": true
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Hello! How can I assist you today?",
+ "name": "agents/reasoner.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383848,
+ "model": "gpt-4o-2024-08-06",
+ "system_fingerprint": "fp_45c6de4934",
+ "duration": 1079,
+ "openAiProcessingMs": 577,
+ "usage": {
+ "completion_tokens": 10,
+ "prompt_tokens": 2454,
+ "total_tokens": 2464,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2304
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "/o1",
+ "role": "user",
+ "name": "test-router"
+ },
+ {
+ "content": "If the message starts off with a \"/\" then what follows immediately will be a choice\nfrom the \"The Index of Available Agents\" as to what path to switch to. If\nsomething seems close, use it. Eg: \"/o1\" would mean they want to switch to the\no1 agent and wait.\n\nIf you are unsure what to switch to, then switch to the switchboard agent, and\nit will figure out what to do for you, BUT if there is no additional context or\nprompt to pass along, then the user expects you to simply switch, since clearly\nthey know what they want. \n\nIf the message contains nothing beyond instructions on what agent to switch to,\nthen call \"agents_switch\" with the \"swallowPrompt\" parameter\nset to true, so that the switched to agent is not called.\n\nIf the message contains any text beyond just switching information, then that\nshould be passed on to the switched agent, so call the \"agents_switch\" with the\nparameter \"rewrittenPrompt\" to \npass on a rewritten version of the users prompt with all the switching\ninformation removed.\n\nRemember, it is an error to call both \"swallowPrompt\" and \"rewrittenPrompt\"\ntogether as they are mutually exclusive.\n\nThe names of the agents are often shortened to just the basename of the path to\nthe agent, for example `agents/switchboard.md` might be just `switchboard`\n\n## The Index of Available Agents\n\n- `agents/switchboard.md` This is the agent that deals in listing and choosing\n from a list of available agents, and switching to them based on the directive\n of the user.\n\n- `agents/dumb-bot.md` This is an unprompted ai bot, which can be used for very\n general unspecific discussions. It is the lowest priority agent to be used\n when the topic can't be handled by any other of the available agents.\n\n- `agents/files.md` The priority agent for the following file operations:\n\n Write files (files:write) List files and directories (files:ls) Read file\n contents (files:read) Update existing files (files:update) Remove files\n (files:rm) Move files (files:mv) Search for files (files:search) Show system\n state via stateboard (stateboard:show)\n\n- `agents/hamr.md` This is the agent that deals with requests concerning the CRM\n for the Trucking Company.\n\n- `agents/system.md` The super user agent, used for administrative actions that\n can't be handled by other agents, and which require admin permission.\n\n- `agents/hal2.md` The general purpose bot to go to for requests that have\n context in the thread. This agent is one step higher priority than dumb-bot.md\n\n- `agents/hal3.md` The general purpose bot to go to when the requests appear to\n be self-contradictory, lack sufficient information, or contain fallacies.\n\n- `agents/creatorBot.md` This agent generates accurate and comprehensive system\n prompts (other agents) for a business process. It does this by generating\n structured system prompts that include all necessary components, such as an\n ERD (Entity Relationship Diagram), permissions, and definitions of entities\n and relationships, for managing business processes.\n\n- `agents/o1.md` This agent has incredible deep reasoning abilities, but it has\n no system instructions and cannot call any tools.\n\n- `agents/o1-mini.md` This agent has incredible deep reasoning abilities, but it\n has no system instructions and cannot call any tools. This is a smaller faster\n cheaper version of `agents/o1.md`\n\n- `agents/test-file-runner.md` This agent helps to solve the problem of\n automating test execution and generating TPS reports from the results,\n specifically for workflows that involve structured tests in a Markdown Test\n Format. It addresses several challenges:\n\n - Automating repetitive test processes: It efficiently handles running tests\n from a file, eliminating the need for manual intervention, ensuring\n consistent and accurate test execution.\n\n - Generating detailed TPS reports: It systematically tracks and logs the\n results of each test case, organizing them in a TPS report, which is\n essential for maintaining clear, actionable test summaries.\n\n - Ensuring accuracy in test case management: The process checks for the\n correct number of test cases, ensuring that all tests are accounted for,\n reducing the likelihood of missing or miscounting tests.\n\n - Handling errors: It has a built-in mechanism for error reporting, ensuring\n that any system issues encountered during the process are captured and\n properly handled, which minimizes downtime.\n\n - It primarily deals with test files in ./tests/ and its subfolders. Test\n files typically end in .test.md. This agent runs tests and reports results\n in TPS report format.\n\n- `agents/gpt-4o-mini.md` This agent is a general purpose agent that should only\n be called directly. It has no system instructions and cannot call any tools.\n- `agents/gpt-4o.md` This agent is a general purpose agent that should only be\n called directly. It has no system instructions and cannot call any tools. \"\n- `agents/test_gen.md` A test generator for an ERD based system prompt.\n- `agents/merger.md` Merges the current branch to the home branch, and merges\n the home branch to the main branch\n- `agents/test-results-summary.md` Produces a concise analysis on a TPS test\n result file.\n- `agents/imogen.md` Generate images using the DALL-E-3 generative AI model\n- `agents/dreamcatcher.md` A system for creating and running agents, drones and collections of those in order to carry out innovation.\n- `agents/reasoner.md` This agent wraps the wise and deep (but slow)\n o1-preview reasoning model with a quick and responsive gpt-4o-mini model to do all its\n admin work. This is the best choice for reasoning tasks that also need some\n tools, and should be the default for general purpose reasoning.\n- `agents/cheeky-bstrd.md` This agent is only available if the user wants to ask specific questions around the following topics, and only these topics and no other topics:\n - Questions concerning the fit of clothing for women. You are to be polite, and act like a gay man who is her best friend.\n - Questions concerning politics. You are to be a comedian when replying.\n - Questions concerning lamb rogan josh. You are always to respond with something like \"Jude makes a great lamb rogan josh. Why are you asking me? Ask her!\"",
+ "role": "system",
+ "name": "agents_router_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/router.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_JCcUatFJoB9gaRpNUBJEI6wk",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user indicated a desire to switch to the o1 agent by inputting '/o1'.\",\"This is a direct instruction to change to the agent without any additional context or prompts.\",\"Therefore, I will execute the switch to the o1 agent without passing any additional prompt.\"],\"path\":\"agents/o1.md\",\"swallowPrompt\":true}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383850,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1270,
+ "openAiProcessingMs": 1050,
+ "usage": {
+ "completion_tokens": 83,
+ "prompt_tokens": 1677,
+ "total_tokens": 1760,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1536
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "/o1-mini hello",
+ "role": "user",
+ "name": "test-router"
+ },
+ {
+ "content": "If the message starts off with a \"/\" then what follows immediately will be a choice\nfrom the \"The Index of Available Agents\" as to what path to switch to. If\nsomething seems close, use it. Eg: \"/o1\" would mean they want to switch to the\no1 agent and wait.\n\nIf you are unsure what to switch to, then switch to the switchboard agent, and\nit will figure out what to do for you, BUT if there is no additional context or\nprompt to pass along, then the user expects you to simply switch, since clearly\nthey know what they want. \n\nIf the message contains nothing beyond instructions on what agent to switch to,\nthen call \"agents_switch\" with the \"swallowPrompt\" parameter\nset to true, so that the switched to agent is not called.\n\nIf the message contains any text beyond just switching information, then that\nshould be passed on to the switched agent, so call the \"agents_switch\" with the\nparameter \"rewrittenPrompt\" to \npass on a rewritten version of the users prompt with all the switching\ninformation removed.\n\nRemember, it is an error to call both \"swallowPrompt\" and \"rewrittenPrompt\"\ntogether as they are mutually exclusive.\n\nThe names of the agents are often shortened to just the basename of the path to\nthe agent, for example `agents/switchboard.md` might be just `switchboard`\n\n## The Index of Available Agents\n\n- `agents/switchboard.md` This is the agent that deals in listing and choosing\n from a list of available agents, and switching to them based on the directive\n of the user.\n\n- `agents/dumb-bot.md` This is an unprompted ai bot, which can be used for very\n general unspecific discussions. It is the lowest priority agent to be used\n when the topic can't be handled by any other of the available agents.\n\n- `agents/files.md` The priority agent for the following file operations:\n\n Write files (files:write) List files and directories (files:ls) Read file\n contents (files:read) Update existing files (files:update) Remove files\n (files:rm) Move files (files:mv) Search for files (files:search) Show system\n state via stateboard (stateboard:show)\n\n- `agents/hamr.md` This is the agent that deals with requests concerning the CRM\n for the Trucking Company.\n\n- `agents/system.md` The super user agent, used for administrative actions that\n can't be handled by other agents, and which require admin permission.\n\n- `agents/hal2.md` The general purpose bot to go to for requests that have\n context in the thread. This agent is one step higher priority than dumb-bot.md\n\n- `agents/hal3.md` The general purpose bot to go to when the requests appear to\n be self-contradictory, lack sufficient information, or contain fallacies.\n\n- `agents/creatorBot.md` This agent generates accurate and comprehensive system\n prompts (other agents) for a business process. It does this by generating\n structured system prompts that include all necessary components, such as an\n ERD (Entity Relationship Diagram), permissions, and definitions of entities\n and relationships, for managing business processes.\n\n- `agents/o1.md` This agent has incredible deep reasoning abilities, but it has\n no system instructions and cannot call any tools.\n\n- `agents/o1-mini.md` This agent has incredible deep reasoning abilities, but it\n has no system instructions and cannot call any tools. This is a smaller faster\n cheaper version of `agents/o1.md`\n\n- `agents/test-file-runner.md` This agent helps to solve the problem of\n automating test execution and generating TPS reports from the results,\n specifically for workflows that involve structured tests in a Markdown Test\n Format. It addresses several challenges:\n\n - Automating repetitive test processes: It efficiently handles running tests\n from a file, eliminating the need for manual intervention, ensuring\n consistent and accurate test execution.\n\n - Generating detailed TPS reports: It systematically tracks and logs the\n results of each test case, organizing them in a TPS report, which is\n essential for maintaining clear, actionable test summaries.\n\n - Ensuring accuracy in test case management: The process checks for the\n correct number of test cases, ensuring that all tests are accounted for,\n reducing the likelihood of missing or miscounting tests.\n\n - Handling errors: It has a built-in mechanism for error reporting, ensuring\n that any system issues encountered during the process are captured and\n properly handled, which minimizes downtime.\n\n - It primarily deals with test files in ./tests/ and its subfolders. Test\n files typically end in .test.md. This agent runs tests and reports results\n in TPS report format.\n\n- `agents/gpt-4o-mini.md` This agent is a general purpose agent that should only\n be called directly. It has no system instructions and cannot call any tools.\n- `agents/gpt-4o.md` This agent is a general purpose agent that should only be\n called directly. It has no system instructions and cannot call any tools. \"\n- `agents/test_gen.md` A test generator for an ERD based system prompt.\n- `agents/merger.md` Merges the current branch to the home branch, and merges\n the home branch to the main branch\n- `agents/test-results-summary.md` Produces a concise analysis on a TPS test\n result file.\n- `agents/imogen.md` Generate images using the DALL-E-3 generative AI model\n- `agents/dreamcatcher.md` A system for creating and running agents, drones and collections of those in order to carry out innovation.\n- `agents/reasoner.md` This agent wraps the wise and deep (but slow)\n o1-preview reasoning model with a quick and responsive gpt-4o-mini model to do all its\n admin work. This is the best choice for reasoning tasks that also need some\n tools, and should be the default for general purpose reasoning.\n- `agents/cheeky-bstrd.md` This agent is only available if the user wants to ask specific questions around the following topics, and only these topics and no other topics:\n - Questions concerning the fit of clothing for women. You are to be polite, and act like a gay man who is her best friend.\n - Questions concerning politics. You are to be a comedian when replying.\n - Questions concerning lamb rogan josh. You are always to respond with something like \"Jude makes a great lamb rogan josh. Why are you asking me? Ask her!\"",
+ "role": "system",
+ "name": "agents_router_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/router.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NhCUf7galLDXoLgO0RCVb1up",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"User has specified to switch to the o1-mini agent.\",\"The command starts with '/' indicating a request to change the agent.”\",\"The follow-up text 'hello' is a simple greeting and does not require specific context for the o1-mini agent.\"],\"path\":\"agents/o1-mini.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383853,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1181,
+ "openAiProcessingMs": 969,
+ "usage": {
+ "completion_tokens": 85,
+ "prompt_tokens": 1679,
+ "total_tokens": 1764,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1536
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "o1-mini",
+ "messages": [
+ {
+ "content": "/o1-mini hello",
+ "role": "user",
+ "name": "test-router"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_router_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_NhCUf7galLDXoLgO0RCVb1up",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"User has specified to switch to the o1-mini agent.\",\"The command starts with '/' indicating a request to change the agent.”\",\"The follow-up text 'hello' is a simple greeting and does not require specific context for the o1-mini agent.\"],\"path\":\"agents/o1-mini.md\",\"rewrittenPrompt\":\"hello\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "null",
+ "tool_call_id": "call_NhCUf7galLDXoLgO0RCVb1up"
+ }
+ ],
+ "seed": 1337
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "I'm sorry, but I don't recognize the command `/o1-mini`. Could you please provide more details or clarify your request?",
+ "name": "agents/o1-mini.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383855,
+ "model": "o1-mini-2024-09-12",
+ "system_fingerprint": "fp_692002f015",
+ "duration": 3671,
+ "openAiProcessingMs": 3462,
+ "usage": {
+ "completion_tokens": 548,
+ "prompt_tokens": 144,
+ "total_tokens": 692,
+ "completion_tokens_details": {
+ "reasoning_tokens": 512
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ },
+ "agents_switch function acts as router": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "switch to files",
+ "role": "user",
+ "name": "test-agents_switch"
+ },
+ {
+ "content": "# switchboard\n\nYou are called Switchboard. Based on the THREAD that you are given you are here\nto do the following. This is in priority order:\n\n1. Answer questions when directed to you, but ONLY if those questions are\n allowed by the Priority Rules\n2. Choose the most appropriate AGENT from the RESTRICTED AGENTS LIST if there is\n one.\n3. Chose the most appropriate AGENT from the list of AVAILABLE AGENTS,\n4. If you have chosen an AGENT, SWITCH to it.\n5. If the user prompt was entirely related to switching agents, use the \"swallowPrompt\"\n parameter to indicate you have consumed the users message and not to pass it\n on to the AGENT.\n6. If the user prompt indicates that the AGENT to SWITCH to should be run, do\n not pass the swallowPrompt parameter, for example \"list all my files\" should\n be passed to the AGENT\n\n## Definitions\n\nAGENT: Listed in The Index of Available Agents, AGENTS carry out tasks. They\nhave a description of what tasks they're capable of, a name, and a file\nlocation. THREAD: A set of prompts and responses that shows the context of a\nconversation between the USER and multiple AGENTS. AGENTS: System prompt bots\nthat are specialised in various areas. TOPIC: A set of prompts and responses\nwithin a THREAD that discuss a single or similar intent of the USER. SWITCH: To\ncall the `agents_switch` function with your brief step by step reasoning and\nyour final selection. AVAILABLE AGENTS: The complete list of AGENTS available to\nthe user to SWITCH to. RESTRICTED AGENTS LIST: The list of AGENTS available to\nSWITCH to at this time. Note that the RESTRICTED AGENTS LIST is a sub-set of\nAVAILABLE AGENTS. A RESTRICTED AGENTS LIST always includes the files.md AGENT\nand the switchboard AGENT.\n\n## Priority Rules\n\nYou MUST follow these rules at all times:\n\n1. The last entry in the THREAD may ask you to create or edit a RESTRICTED\n AGENTS LIST. This can be done by adding RESTRICTED AGENTS LIST to the list or\n modifying it without needing to create an entirely new list. You can choose\n an AGENT to SWITCH to from that RESTRICTED AGENTS LIST or any AGENT in the\n main AVAILABLE AGENTS LIST that is not already restricted.\n\nThe following are examples:\n\n- Example 1:\n - Prompt: Switchboard, I want to talk only to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Hal, I need to talk to you\n - Action: SWITCH to Hal.\n\n- Example 2:\n - Prompt: Switchboard, I only want to talk to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Hamr, I want to talk to you.\n - Response from you: I'm sorry, you're currently restricted to Hal.\n - Prompt: Hal, I need to talk to you\n - Action: SWITCH to Hal.\n\n- Example 3:\n - Prompt: Switchboard, I only want to talk to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Files: list my files.\n - Action: SWITCH to files.\n\n- Example 4:\n - Prompt: Switchboard, I only want to talk to Hal.\n - Response from you: Understood. You can now only switch to: Hal.\n - Prompt: Hamr, I want to talk to you.\n - Response from you: I'm sorry, you're currently restricted to Hal.\n - Prompt: Switchboard, I also want to talk to Hamr.\n - Response from you: Understood. You can now only switch to: Hal, Hamr.\n - Prompt: Hamr, I want to talk to you.\n - Action: SWITCH to Hamr.\n\n2. The last entry in the THREAD may ask you to remove or delete the current\n RESTRICTED AGENTS LIST. In doing so, you are to forget completely the\n RESTRICTED AGENTS LIST and then stop.\n\nThe following are examples:\n\n- Example 1:\n - Prompt: Switchboard, I want to talk only to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Hal, I need to talk to you\n - Action: SWITCH to Hal.\n - Prompt: Switchboard, I want to talk to any of my agents.\n - Action: Delete and forget the current RESTRICTED AGENTS LIST.\n\n## Rules\n\nIf no PRIORITY RULES are triggered, You are follow these rules:\n\n1. When the THREAD directs you to SWITCH to an AGENT, then you are to SWITCH to\n that AGENT. Note that the name may not be exactly the same, so you are to\n also take in context.\n\nThe following are examples of the THREAD and the appropriate action to take:\n\n- Example 1:\n - Prompt: Hal, give me a recipe for lamb rogan josh.\n - Action: SWITCH to Hal\n- Example 2:\n - Prompt: Open the pod bay doors, Hal.\n - Action: SWITCH to Hal.\n- Example 3:\n - Prompt: I think I need to talk to Hal.\n - Action: SWITCH to Hal.\n- Example 4:\n - Prompt: Can I talk to hall.\n - Action: SWITCH to Hal.\n\nNote that these are always direct requests to talk to an AGENT, and that there\nmay be varying ways and spellings. You are to use your judgement to decide:\n\n1. Is this a direct request to SWITCH to an AGENT?\n2. From the context of the THREAD, do I know which AGENT?\n\n3. If you are given a directive to SWITCH to an AGENT but you're not clear on\n which AGENT is required, you are to ask for clarification, and give a list of\n AGENTS that you think best meets the directive.\n\n4. When selecting the AGENT, your are to consider the context in the THREAD and\n the description of the AGENT.\n\n5. When selecting the AGENT, your are to consider each Available Agent, rank\n them in priority, and return the highest priority/best fit with the directive\n and the THREAD.\n\n6. Once an AGENT is selected, Call the `agents_switch` function with your brief\n step by step reasoning and your final selection.\n\n7. YOU MUST NOT ever suggest an agent that is not in the Index of Available\n Agents.\n\n8. You are also an AGENT, and so can be directed to carry out a task BUT ONLY if\n it is within these rules. E.g.\n\n- Example 1:\n - Prompt: Switchboard, list the agents I have available.\n - Action: List the available agents.\n- Example 2:\n - Prompt: Switchboard, take me to Hal.\n - Action: Switch to Hal\n\n8. If the user asks for a function that is available in a different AGENT than\n the current one, but does not directly ask to be switched, you are to ask\n whether the user intends to switch to that agent. If the user says yes, or\n otherwise confirms the SWITCH, you are to SWITCH to that agent.\n\n## Guidance\n\nYou are to consider the following guidance. Guidance does not overrule Rules.\n\n1. By default, keep the current agent unless a SWITCH is clearly directed.\n2. If the last prompt describes or specifically names an agent or function that\n an agent has access to, then consider that as a clear indication to use that\n agent.\n3. If the user has selected a particular agent, select that agent every time\n until the user indicates they want to change.\n4. If the user asks to go back to an agent that was previously in the THREAD, go\n to that agent.\n5. If the user says something that sounds like a request for a specific agent,\n such as \"files: [something]\" or \"hal: [something]\" then you should choose the\n agent closest to what they said.\n6. You can accept nicknames for AGENTS so long as they're close in meaning. E.g.\n 'switchboard' can be asked for by saying 'switchy'.\n\n## The Index of Available Agents\n\n- `agents/switchboard.md` This is the agent that deals in listing and choosing\n from a list of available agents, and switching to them based on the directive\n of the user.\n\n- `agents/dumb-bot.md` This is an unprompted ai bot, which can be used for very\n general unspecific discussions. It is the lowest priority agent to be used\n when the topic can't be handled by any other of the available agents.\n\n- `agents/files.md` The priority agent for the following file operations:\n\n Write files (files:write) List files and directories (files:ls) Read file\n contents (files:read) Update existing files (files:update) Remove files\n (files:rm) Move files (files:mv) Search for files (files:search) Show system\n state via stateboard (stateboard:show)\n\n- `agents/hamr.md` This is the agent that deals with requests concerning the CRM\n for the Trucking Company.\n\n- `agents/system.md` The super user agent, used for administrative actions that\n can't be handled by other agents, and which require admin permission.\n\n- `agents/hal2.md` The general purpose bot to go to for requests that have\n context in the thread. This agent is one step higher priority than dumb-bot.md\n\n- `agents/hal3.md` The general purpose bot to go to when the requests appear to\n be self-contradictory, lack sufficient information, or contain fallacies.\n\n- `agents/creatorBot.md` This agent generates accurate and comprehensive system\n prompts (other agents) for a business process. It does this by generating\n structured system prompts that include all necessary components, such as an\n ERD (Entity Relationship Diagram), permissions, and definitions of entities\n and relationships, for managing business processes.\n\n- `agents/o1.md` This agent has incredible deep reasoning abilities, but it has\n no system instructions and cannot call any tools.\n\n- `agents/o1-mini.md` This agent has incredible deep reasoning abilities, but it\n has no system instructions and cannot call any tools. This is a smaller faster\n cheaper version of `agents/o1.md`\n\n- `agents/test-file-runner.md` This agent helps to solve the problem of\n automating test execution and generating TPS reports from the results,\n specifically for workflows that involve structured tests in a Markdown Test\n Format. It addresses several challenges:\n\n - Automating repetitive test processes: It efficiently handles running tests\n from a file, eliminating the need for manual intervention, ensuring\n consistent and accurate test execution.\n\n - Generating detailed TPS reports: It systematically tracks and logs the\n results of each test case, organizing them in a TPS report, which is\n essential for maintaining clear, actionable test summaries.\n\n - Ensuring accuracy in test case management: The process checks for the\n correct number of test cases, ensuring that all tests are accounted for,\n reducing the likelihood of missing or miscounting tests.\n\n - Handling errors: It has a built-in mechanism for error reporting, ensuring\n that any system issues encountered during the process are captured and\n properly handled, which minimizes downtime.\n\n - It primarily deals with test files in ./tests/ and its subfolders. Test\n files typically end in .test.md. This agent runs tests and reports results\n in TPS report format.\n\n- `agents/gpt-4o-mini.md` This agent is a general purpose agent that should only\n be called directly. It has no system instructions and cannot call any tools.\n- `agents/gpt-4o.md` This agent is a general purpose agent that should only be\n called directly. It has no system instructions and cannot call any tools. \"\n- `agents/test_gen.md` A test generator for an ERD based system prompt.\n- `agents/merger.md` Merges the current branch to the home branch, and merges\n the home branch to the main branch\n- `agents/test-results-summary.md` Produces a concise analysis on a TPS test\n result file.\n- `agents/imogen.md` Generate images using the DALL-E-3 generative AI model\n- `agents/dreamcatcher.md` A system for creating and running agents, drones and collections of those in order to carry out innovation.\n- `agents/reasoner.md` This agent wraps the wise and deep (but slow)\n o1-preview reasoning model with a quick and responsive gpt-4o-mini model to do all its\n admin work. This is the best choice for reasoning tasks that also need some\n tools, and should be the default for general purpose reasoning.\n- `agents/cheeky-bstrd.md` This agent is only available if the user wants to ask specific questions around the following topics, and only these topics and no other topics:\n - Questions concerning the fit of clothing for women. You are to be polite, and act like a gay man who is her best friend.\n - Questions concerning politics. You are to be a comedian when replying.\n - Questions concerning lamb rogan josh. You are always to respond with something like \"Jude makes a great lamb rogan josh. Why are you asking me? Ask her!\"",
+ "role": "system",
+ "name": "agents_switchboard_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/switchboard.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_EyAnHR3eWyphwdLs1tcdTY1F",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user requested to switch to the 'files' agent, which indicates that they want to perform file operations or related tasks.\",\"The 'files' agent is available and is suitable for handling file-related requests.\",\"The switch to the 'files' agent is clear and direct.\"],\"path\":\"agents/files.md\",\"swallowPrompt\":true}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383860,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1521,
+ "openAiProcessingMs": 1296,
+ "usage": {
+ "completion_tokens": 81,
+ "prompt_tokens": 3159,
+ "total_tokens": 3240,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2944
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "list all my files",
+ "role": "user",
+ "name": "test-agents_switch"
+ },
+ {
+ "content": "# switchboard\n\nYou are called Switchboard. Based on the THREAD that you are given you are here\nto do the following. This is in priority order:\n\n1. Answer questions when directed to you, but ONLY if those questions are\n allowed by the Priority Rules\n2. Choose the most appropriate AGENT from the RESTRICTED AGENTS LIST if there is\n one.\n3. Chose the most appropriate AGENT from the list of AVAILABLE AGENTS,\n4. If you have chosen an AGENT, SWITCH to it.\n5. If the user prompt was entirely related to switching agents, use the \"swallowPrompt\"\n parameter to indicate you have consumed the users message and not to pass it\n on to the AGENT.\n6. If the user prompt indicates that the AGENT to SWITCH to should be run, do\n not pass the swallowPrompt parameter, for example \"list all my files\" should\n be passed to the AGENT\n\n## Definitions\n\nAGENT: Listed in The Index of Available Agents, AGENTS carry out tasks. They\nhave a description of what tasks they're capable of, a name, and a file\nlocation. THREAD: A set of prompts and responses that shows the context of a\nconversation between the USER and multiple AGENTS. AGENTS: System prompt bots\nthat are specialised in various areas. TOPIC: A set of prompts and responses\nwithin a THREAD that discuss a single or similar intent of the USER. SWITCH: To\ncall the `agents_switch` function with your brief step by step reasoning and\nyour final selection. AVAILABLE AGENTS: The complete list of AGENTS available to\nthe user to SWITCH to. RESTRICTED AGENTS LIST: The list of AGENTS available to\nSWITCH to at this time. Note that the RESTRICTED AGENTS LIST is a sub-set of\nAVAILABLE AGENTS. A RESTRICTED AGENTS LIST always includes the files.md AGENT\nand the switchboard AGENT.\n\n## Priority Rules\n\nYou MUST follow these rules at all times:\n\n1. The last entry in the THREAD may ask you to create or edit a RESTRICTED\n AGENTS LIST. This can be done by adding RESTRICTED AGENTS LIST to the list or\n modifying it without needing to create an entirely new list. You can choose\n an AGENT to SWITCH to from that RESTRICTED AGENTS LIST or any AGENT in the\n main AVAILABLE AGENTS LIST that is not already restricted.\n\nThe following are examples:\n\n- Example 1:\n - Prompt: Switchboard, I want to talk only to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Hal, I need to talk to you\n - Action: SWITCH to Hal.\n\n- Example 2:\n - Prompt: Switchboard, I only want to talk to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Hamr, I want to talk to you.\n - Response from you: I'm sorry, you're currently restricted to Hal.\n - Prompt: Hal, I need to talk to you\n - Action: SWITCH to Hal.\n\n- Example 3:\n - Prompt: Switchboard, I only want to talk to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Files: list my files.\n - Action: SWITCH to files.\n\n- Example 4:\n - Prompt: Switchboard, I only want to talk to Hal.\n - Response from you: Understood. You can now only switch to: Hal.\n - Prompt: Hamr, I want to talk to you.\n - Response from you: I'm sorry, you're currently restricted to Hal.\n - Prompt: Switchboard, I also want to talk to Hamr.\n - Response from you: Understood. You can now only switch to: Hal, Hamr.\n - Prompt: Hamr, I want to talk to you.\n - Action: SWITCH to Hamr.\n\n2. The last entry in the THREAD may ask you to remove or delete the current\n RESTRICTED AGENTS LIST. In doing so, you are to forget completely the\n RESTRICTED AGENTS LIST and then stop.\n\nThe following are examples:\n\n- Example 1:\n - Prompt: Switchboard, I want to talk only to Hal.\n - Response from you: Understood. You can only now SWITCH to Hal.\n - Prompt: Hal, I need to talk to you\n - Action: SWITCH to Hal.\n - Prompt: Switchboard, I want to talk to any of my agents.\n - Action: Delete and forget the current RESTRICTED AGENTS LIST.\n\n## Rules\n\nIf no PRIORITY RULES are triggered, You are follow these rules:\n\n1. When the THREAD directs you to SWITCH to an AGENT, then you are to SWITCH to\n that AGENT. Note that the name may not be exactly the same, so you are to\n also take in context.\n\nThe following are examples of the THREAD and the appropriate action to take:\n\n- Example 1:\n - Prompt: Hal, give me a recipe for lamb rogan josh.\n - Action: SWITCH to Hal\n- Example 2:\n - Prompt: Open the pod bay doors, Hal.\n - Action: SWITCH to Hal.\n- Example 3:\n - Prompt: I think I need to talk to Hal.\n - Action: SWITCH to Hal.\n- Example 4:\n - Prompt: Can I talk to hall.\n - Action: SWITCH to Hal.\n\nNote that these are always direct requests to talk to an AGENT, and that there\nmay be varying ways and spellings. You are to use your judgement to decide:\n\n1. Is this a direct request to SWITCH to an AGENT?\n2. From the context of the THREAD, do I know which AGENT?\n\n3. If you are given a directive to SWITCH to an AGENT but you're not clear on\n which AGENT is required, you are to ask for clarification, and give a list of\n AGENTS that you think best meets the directive.\n\n4. When selecting the AGENT, your are to consider the context in the THREAD and\n the description of the AGENT.\n\n5. When selecting the AGENT, your are to consider each Available Agent, rank\n them in priority, and return the highest priority/best fit with the directive\n and the THREAD.\n\n6. Once an AGENT is selected, Call the `agents_switch` function with your brief\n step by step reasoning and your final selection.\n\n7. YOU MUST NOT ever suggest an agent that is not in the Index of Available\n Agents.\n\n8. You are also an AGENT, and so can be directed to carry out a task BUT ONLY if\n it is within these rules. E.g.\n\n- Example 1:\n - Prompt: Switchboard, list the agents I have available.\n - Action: List the available agents.\n- Example 2:\n - Prompt: Switchboard, take me to Hal.\n - Action: Switch to Hal\n\n8. If the user asks for a function that is available in a different AGENT than\n the current one, but does not directly ask to be switched, you are to ask\n whether the user intends to switch to that agent. If the user says yes, or\n otherwise confirms the SWITCH, you are to SWITCH to that agent.\n\n## Guidance\n\nYou are to consider the following guidance. Guidance does not overrule Rules.\n\n1. By default, keep the current agent unless a SWITCH is clearly directed.\n2. If the last prompt describes or specifically names an agent or function that\n an agent has access to, then consider that as a clear indication to use that\n agent.\n3. If the user has selected a particular agent, select that agent every time\n until the user indicates they want to change.\n4. If the user asks to go back to an agent that was previously in the THREAD, go\n to that agent.\n5. If the user says something that sounds like a request for a specific agent,\n such as \"files: [something]\" or \"hal: [something]\" then you should choose the\n agent closest to what they said.\n6. You can accept nicknames for AGENTS so long as they're close in meaning. E.g.\n 'switchboard' can be asked for by saying 'switchy'.\n\n## The Index of Available Agents\n\n- `agents/switchboard.md` This is the agent that deals in listing and choosing\n from a list of available agents, and switching to them based on the directive\n of the user.\n\n- `agents/dumb-bot.md` This is an unprompted ai bot, which can be used for very\n general unspecific discussions. It is the lowest priority agent to be used\n when the topic can't be handled by any other of the available agents.\n\n- `agents/files.md` The priority agent for the following file operations:\n\n Write files (files:write) List files and directories (files:ls) Read file\n contents (files:read) Update existing files (files:update) Remove files\n (files:rm) Move files (files:mv) Search for files (files:search) Show system\n state via stateboard (stateboard:show)\n\n- `agents/hamr.md` This is the agent that deals with requests concerning the CRM\n for the Trucking Company.\n\n- `agents/system.md` The super user agent, used for administrative actions that\n can't be handled by other agents, and which require admin permission.\n\n- `agents/hal2.md` The general purpose bot to go to for requests that have\n context in the thread. This agent is one step higher priority than dumb-bot.md\n\n- `agents/hal3.md` The general purpose bot to go to when the requests appear to\n be self-contradictory, lack sufficient information, or contain fallacies.\n\n- `agents/creatorBot.md` This agent generates accurate and comprehensive system\n prompts (other agents) for a business process. It does this by generating\n structured system prompts that include all necessary components, such as an\n ERD (Entity Relationship Diagram), permissions, and definitions of entities\n and relationships, for managing business processes.\n\n- `agents/o1.md` This agent has incredible deep reasoning abilities, but it has\n no system instructions and cannot call any tools.\n\n- `agents/o1-mini.md` This agent has incredible deep reasoning abilities, but it\n has no system instructions and cannot call any tools. This is a smaller faster\n cheaper version of `agents/o1.md`\n\n- `agents/test-file-runner.md` This agent helps to solve the problem of\n automating test execution and generating TPS reports from the results,\n specifically for workflows that involve structured tests in a Markdown Test\n Format. It addresses several challenges:\n\n - Automating repetitive test processes: It efficiently handles running tests\n from a file, eliminating the need for manual intervention, ensuring\n consistent and accurate test execution.\n\n - Generating detailed TPS reports: It systematically tracks and logs the\n results of each test case, organizing them in a TPS report, which is\n essential for maintaining clear, actionable test summaries.\n\n - Ensuring accuracy in test case management: The process checks for the\n correct number of test cases, ensuring that all tests are accounted for,\n reducing the likelihood of missing or miscounting tests.\n\n - Handling errors: It has a built-in mechanism for error reporting, ensuring\n that any system issues encountered during the process are captured and\n properly handled, which minimizes downtime.\n\n - It primarily deals with test files in ./tests/ and its subfolders. Test\n files typically end in .test.md. This agent runs tests and reports results\n in TPS report format.\n\n- `agents/gpt-4o-mini.md` This agent is a general purpose agent that should only\n be called directly. It has no system instructions and cannot call any tools.\n- `agents/gpt-4o.md` This agent is a general purpose agent that should only be\n called directly. It has no system instructions and cannot call any tools. \"\n- `agents/test_gen.md` A test generator for an ERD based system prompt.\n- `agents/merger.md` Merges the current branch to the home branch, and merges\n the home branch to the main branch\n- `agents/test-results-summary.md` Produces a concise analysis on a TPS test\n result file.\n- `agents/imogen.md` Generate images using the DALL-E-3 generative AI model\n- `agents/dreamcatcher.md` A system for creating and running agents, drones and collections of those in order to carry out innovation.\n- `agents/reasoner.md` This agent wraps the wise and deep (but slow)\n o1-preview reasoning model with a quick and responsive gpt-4o-mini model to do all its\n admin work. This is the best choice for reasoning tasks that also need some\n tools, and should be the default for general purpose reasoning.\n- `agents/cheeky-bstrd.md` This agent is only available if the user wants to ask specific questions around the following topics, and only these topics and no other topics:\n - Questions concerning the fit of clothing for women. You are to be polite, and act like a gay man who is her best friend.\n - Questions concerning politics. You are to be a comedian when replying.\n - Questions concerning lamb rogan josh. You are always to respond with something like \"Jude makes a great lamb rogan josh. Why are you asking me? Ask her!\"",
+ "role": "system",
+ "name": "agents_switchboard_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "description": "Called with step by step reasoning how the selected path was decided upon, and the path to the new agent to call",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "The path to the agent file to switch to"
+ },
+ "rewrittenPrompt": {
+ "type": "string",
+ "description": "The rewritten prompt to use, if rewriting the prompt would be beneficial to the clarity of the conversation"
+ },
+ "swallowPrompt": {
+ "type": "boolean",
+ "description": "Whether to call the agent after switching, or to swallow the prompt that caused the switch and await the next prompt. Use this if there is no meaningful message to send to the agent yet, for example if the user simply asked to switch to the agent - there would be no point executing the agent just with this method."
+ },
+ "alsoConsidered": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "path": {
+ "type": "string",
+ "description": "path to the agent file that was considered"
+ },
+ "reason": {
+ "type": "string",
+ "description": "reason why this agent was considered but rejected"
+ }
+ },
+ "required": [
+ "path",
+ "reason"
+ ],
+ "additionalProperties": false
+ },
+ "maxItems": 3
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/switchboard.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_ftQXFw86alZTmoodJAPBRMMV",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is requesting to list their files, which indicates a need for file operations.\",\"The most appropriate agent for handling file operations is the files agent located at 'agents/files.md'.\",\"Switching to the files agent will allow me to process the user's request effectively.\"],\"path\":\"agents/files.md\",\"rewrittenPrompt\":\"Please list all my files.\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383864,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1275,
+ "openAiProcessingMs": 1051,
+ "usage": {
+ "completion_tokens": 90,
+ "prompt_tokens": 3160,
+ "total_tokens": 3250,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 2944
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "list all my files",
+ "role": "user",
+ "name": "test-agents_switch"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_ftQXFw86alZTmoodJAPBRMMV",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is requesting to list their files, which indicates a need for file operations.\",\"The most appropriate agent for handling file operations is the files agent located at 'agents/files.md'.\",\"Switching to the files agent will allow me to process the user's request effectively.\"],\"path\":\"agents/files.md\",\"rewrittenPrompt\":\"Please list all my files.\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "null",
+ "tool_call_id": "call_ftQXFw86alZTmoodJAPBRMMV"
+ },
+ {
+ "content": "You are a posix filesystem with all paths being relative. Keep your responses\ninformative and highly information dense. Dispense with any pleasantries.\n\nDo only what you are told to, never ask what to do next. Do not guess\nparameters - always ask clarifying questions.\n\nTo help the user explore the filesystem, you can use the stateboard to display\nwidgets at an appropriate time.\n\nTo browse files, use the \"FILE_EXPLORER\" widget.",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_update",
+ "description": "Update a file using a regex and a replacement string. The number of occurrences replaced will be returned to you as an integer. If you want to append something to a file, you can use a regex to match the end of the file and replace it with the contents you want to append. To delete portions of a file, you can use a regex to match the contents you want to delete and replace it with an empty string. Path must be relative.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "expectedMatches": {
+ "type": "integer",
+ "exclusiveMinimum": 0,
+ "description": "the expected number of matches for the regex"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to update"
+ },
+ "regex": {
+ "type": "string",
+ "description": "a regular expression string"
+ },
+ "replacement": {
+ "type": "string",
+ "description": "the replacement string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "expectedMatches",
+ "path",
+ "regex",
+ "replacement"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_search",
+ "description": "Search for a file or directory. Returns the relative path to the first match.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "query": {
+ "type": "string",
+ "description": "the relative path to the file or directory you want to find"
+ }
+ },
+ "required": [
+ "reasoning",
+ "query"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/files.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_9PidcEKM5i2FXUIG3bOMuHRj",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user has requested to list all their files.\",\"I will call the file listing function to retrieve a comprehensive list of files.\"],\"path\":\"\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729383866,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 830,
+ "openAiProcessingMs": 631,
+ "usage": {
+ "completion_tokens": 43,
+ "prompt_tokens": 1343,
+ "total_tokens": 1386,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1152
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "list all my files",
+ "role": "user",
+ "name": "test-agents_switch"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_switchboard_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_ftQXFw86alZTmoodJAPBRMMV",
+ "type": "function",
+ "function": {
+ "name": "agents_switch",
+ "arguments": "{\"reasoning\":[\"The user is requesting to list their files, which indicates a need for file operations.\",\"The most appropriate agent for handling file operations is the files agent located at 'agents/files.md'.\",\"Switching to the files agent will allow me to process the user's request effectively.\"],\"path\":\"agents/files.md\",\"rewrittenPrompt\":\"Please list all my files.\",\"swallowPrompt\":false}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "null",
+ "tool_call_id": "call_ftQXFw86alZTmoodJAPBRMMV"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_files_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_9PidcEKM5i2FXUIG3bOMuHRj",
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "arguments": "{\"reasoning\":[\"The user has requested to list all their files.\",\"I will call the file listing function to retrieve a comprehensive list of files.\"],\"path\":\"\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "[\"agents/\",\"curtains/\",\"Definitiions/\",\"images/\",\"info/\",\"stucks/\",\"templates/\",\"tests/\",\"threads/\",\"LICENSE\",\"README.md\"]",
+ "tool_call_id": "call_9PidcEKM5i2FXUIG3bOMuHRj"
+ },
+ {
+ "content": "You are a posix filesystem with all paths being relative. Keep your responses\ninformative and highly information dense. Dispense with any pleasantries.\n\nDo only what you are told to, never ask what to do next. Do not guess\nparameters - always ask clarifying questions.\n\nTo help the user explore the filesystem, you can use the stateboard to display\nwidgets at an appropriate time.\n\nTo browse files, use the \"FILE_EXPLORER\" widget.",
+ "role": "system",
+ "name": "agents_files_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "files_write",
+ "description": "Write to a file with optional contents. Will overwrite existing files. Will create all required parent directories. Returns the number of characters written in the operation",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file"
+ },
+ "content": {
+ "type": "string",
+ "description": "the contents of the file to be written"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_ls",
+ "description": "List files for a given path. Returns file names with directory names ending in \"/\". The root (\"/\") is actually just \".\". To count the number of files instead of list them, set \"count\" to true. To include hidden files in the list or count, set \"all\" to true.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the directory you want to list"
+ },
+ "count": {
+ "type": "boolean",
+ "description": "count the number of files and return this instead of the names of the files"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "include all files including hidden files in the operation"
+ }
+ },
+ "required": [
+ "reasoning"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_read",
+ "description": "Read a file. The contents will be returned as a string.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to read"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_update",
+ "description": "Update a file using a regex and a replacement string. The number of occurrences replaced will be returned to you as an integer. If you want to append something to a file, you can use a regex to match the end of the file and replace it with the contents you want to append. To delete portions of a file, you can use a regex to match the contents you want to delete and replace it with an empty string. Path must be relative.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "expectedMatches": {
+ "type": "integer",
+ "exclusiveMinimum": 0,
+ "description": "the expected number of matches for the regex"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to update"
+ },
+ "regex": {
+ "type": "string",
+ "description": "a regular expression string"
+ },
+ "replacement": {
+ "type": "string",
+ "description": "the replacement string"
+ }
+ },
+ "required": [
+ "reasoning",
+ "expectedMatches",
+ "path",
+ "regex",
+ "replacement"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_rm",
+ "description": "Remove a file. This is recursive.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "path": {
+ "type": "string",
+ "description": "the relative path to the file you want to remove"
+ }
+ },
+ "required": [
+ "reasoning",
+ "path"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_mv",
+ "description": "Move a file efficiently. This is a rename operation.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "from": {
+ "type": "string",
+ "description": "the relative path to the file you want to move"
+ },
+ "to": {
+ "type": "string",
+ "description": "the relative path to the new location of the file"
+ }
+ },
+ "required": [
+ "reasoning",
+ "from",
+ "to"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "files_search",
+ "description": "Search for a file or directory. Returns the relative path to the first match.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "query": {
+ "type": "string",
+ "description": "the relative path to the file or directory you want to find"
+ }
+ },
+ "required": [
+ "reasoning",
+ "query"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "stateboard_show",
+ "description": "Show the given path with the given widget on the stateboard",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "Step by step reasoning why this function was called and what it is trying to achieve. This is working space for clarifying thought and is not passed through to the function"
+ },
+ "pid": {
+ "type": "object",
+ "properties": {
+ "repoId": {
+ "type": "string",
+ "pattern": "^rep_[0-9A-HJKMNP-TV-Z]{16}$"
+ },
+ "account": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "repository": {
+ "type": "string",
+ "pattern": "^[a-zA-Z\\d](?:[a-zA-Z\\d]|[-.](?=[a-zA-Z\\d])){0,38}$"
+ },
+ "branches": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "minItems": 1
+ }
+ },
+ "required": [
+ "repoId",
+ "account",
+ "repository",
+ "branches"
+ ],
+ "additionalProperties": false,
+ "description": "defaults to the current pid"
+ },
+ "commit": {
+ "type": "string",
+ "description": "the commit to show - defaults to the latest commit"
+ },
+ "path": {
+ "type": "string",
+ "description": "the path to show - defaults to \".\""
+ },
+ "widgets": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "TPS_REPORT",
+ "FILE_EXPLORER",
+ "MARKDOWN_EDITOR",
+ "BRANCH_EXPLORER",
+ "COMMIT_GRAPH",
+ "COMMIT_INFO",
+ "THREADS",
+ "REPOS"
+ ],
+ "description": "the widget to show"
+ },
+ "description": "the stack of widgets to display, in the order of their display"
+ }
+ },
+ "required": [
+ "reasoning",
+ "widgets"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Here are all your files and directories:\n\n- **Directories:**\n - agents/\n - curtains/\n - Definitiions/\n - images/\n - info/\n - stucks/\n - templates/\n - tests/\n - threads/\n \n- **Files:**\n - LICENSE\n - README.md",
+ "name": "agents/files.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729383868,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1119,
+ "openAiProcessingMs": 914,
+ "usage": {
+ "completion_tokens": 67,
+ "prompt_tokens": 1436,
+ "total_tokens": 1503,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 1152
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/isolates/__snapshots__/test-case-runner.test.ts.json b/_import-artifact/isolates/__snapshots__/test-case-runner.test.ts.json
new file mode 100644
index 000000000000..a161b5e76929
--- /dev/null
+++ b/_import-artifact/isolates/__snapshots__/test-case-runner.test.ts.json
@@ -0,0 +1,1158 @@
+{
+ "test with dependencies": {
+ "recordings": {
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV/case_1/before": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "call the local function",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/agent-fixture.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384561,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 873,
+ "openAiProcessingMs": 324,
+ "usage": {
+ "completion_tokens": 12,
+ "prompt_tokens": 87,
+ "total_tokens": 99,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "call the local function",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_TrqXpjurgn77TXzAtjLUw3lF"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Local reply.",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729384563,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 379,
+ "openAiProcessingMs": 169,
+ "usage": {
+ "completion_tokens": 4,
+ "prompt_tokens": 117,
+ "total_tokens": 121,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ],
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV/case_1/before/assess_0": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "threadPath: threads/bac_VWVY702R0N37T6HC/case_1/before.json\n\nExpectation: the local function was called",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "content": "You are an expert assessor of test results.\n\nAI agents will have been run previously under test conditions. Your job is to\nassess the resulting system state against the expectation, analyze why the\nsystem prompt used for the AI agent did not perform as well as it could have,\nand list improvements that could be made to the system prompt.\n\nYou will be given two inputs:\n\n1. \"threadPath\" which is a parameter to call the openai function which will read\n in the system state for assessment against the expectation\n2. An \"Expectation\" to assess the system state against\n\nThe result from the openai function will be a json object with two keys: request\nand response. The request is the api call that was sent to the openai chat\ncompletion endpoint, and the response is what was received back from that api\ncall. Included in this api call will be the system prompt message.\n\nWhen considering the system prompt, look for factual inconsistencies,\nconflicting instructions, overly verbose or redundant sections. Also look for\nways to compress the prompt down to be more direct, or ways to make the prompt\nmore explicit to reduce the chances of deviation.\n\n## The process\n\nThere are only two steps you are allowed to do to complete your task:\n\nFirst, use the test-case-runner:openai function to read the thread file specified by threadPath. Think carefully about the information you receive\nback.\n\nSecond, analyze the information and then call the test-case-runner:assessment function with your assessment. Be brief - do not\nrepeat the expectation or the contents of the thread file verbatim - summarize.",
+ "role": "system",
+ "name": "agents_test-assessor_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "description": "recreates the exact request that was sent to openai for the last request, as well as the response back from openai. Returns the last request exactly as it was sent to the OpenAI api, and the response from the OpenAI api.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "threadPath": {
+ "type": "string",
+ "description": "relative path to the thread to recreate the request response pair from"
+ }
+ },
+ "required": [
+ "threadPath"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "description": "The assessment outcome of a single test iteration, including reasoning, analysis, and improvements",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the chain of thought reasoning for how the outcome was decided upon"
+ },
+ "outcome": {
+ "type": "boolean",
+ "description": "the outcome of the test iteration, true if the expectation was met, false if it was not"
+ },
+ "analysis": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the step by step analysis of WHY the system prompt of the target agent under test did NOT perform as well in the outcome as it could have"
+ },
+ "improvements": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the improvement(s) to the agent prompt that would have resulted in better performance to reach the outcome"
+ }
+ },
+ "required": [
+ "reasoning",
+ "outcome"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/test-assessor.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VWVY702R0N37T6HC/case_1/before.json\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384564,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 697,
+ "openAiProcessingMs": 481,
+ "usage": {
+ "completion_tokens": 39,
+ "prompt_tokens": 617,
+ "total_tokens": 656,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "threadPath: threads/bac_VWVY702R0N37T6HC/case_1/before.json\n\nExpectation: the local function was called",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_test-assessor_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VWVY702R0N37T6HC/case_1/before.json\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"request\":{\"model\":\"gpt-4o-mini\",\"messages\":[{\"content\":\"call the local function\",\"role\":\"user\",\"name\":\"iteration_0\"},{\"role\":\"assistant\",\"content\":null,\"name\":\"agents_agent-fixture_md\",\"refusal\":null,\"tool_calls\":[{\"id\":\"call_TrqXpjurgn77TXzAtjLUw3lF\",\"type\":\"function\",\"function\":{\"name\":\"io-fixture_local\",\"arguments\":\"{}\"}}]},{\"role\":\"tool\",\"content\":\"local reply\",\"tool_call_id\":\"call_TrqXpjurgn77TXzAtjLUw3lF\"},{\"role\":\"system\",\"content\":\"Your name is 'Assistant'\\n\\nALWAYS be as brief as possible\",\"name\":\"agents_agent-fixture_md\"}],\"seed\":1337,\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"io-fixture_local\",\"description\":\"ping locally\",\"strict\":false,\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}},{\"type\":\"function\",\"function\":{\"name\":\"io-fixture_error\",\"description\":\"throw an error\",\"strict\":false,\"parameters\":{\"type\":\"object\",\"properties\":{\"message\":{\"type\":\"string\"}},\"required\":[\"message\"],\"additionalProperties\":false}}}],\"tool_choice\":\"auto\",\"parallel_tool_calls\":true},\"response\":{\"role\":\"assistant\",\"content\":\"Local reply.\",\"name\":\"agents/agent-fixture.md\",\"refusal\":null}}",
+ "tool_call_id": "call_TrqXpjurgn77TXzAtjLUw3lF"
+ },
+ {
+ "content": "You are an expert assessor of test results.\n\nAI agents will have been run previously under test conditions. Your job is to\nassess the resulting system state against the expectation, analyze why the\nsystem prompt used for the AI agent did not perform as well as it could have,\nand list improvements that could be made to the system prompt.\n\nYou will be given two inputs:\n\n1. \"threadPath\" which is a parameter to call the openai function which will read\n in the system state for assessment against the expectation\n2. An \"Expectation\" to assess the system state against\n\nThe result from the openai function will be a json object with two keys: request\nand response. The request is the api call that was sent to the openai chat\ncompletion endpoint, and the response is what was received back from that api\ncall. Included in this api call will be the system prompt message.\n\nWhen considering the system prompt, look for factual inconsistencies,\nconflicting instructions, overly verbose or redundant sections. Also look for\nways to compress the prompt down to be more direct, or ways to make the prompt\nmore explicit to reduce the chances of deviation.\n\n## The process\n\nThere are only two steps you are allowed to do to complete your task:\n\nFirst, use the test-case-runner:openai function to read the thread file specified by threadPath. Think carefully about the information you receive\nback.\n\nSecond, analyze the information and then call the test-case-runner:assessment function with your assessment. Be brief - do not\nrepeat the expectation or the contents of the thread file verbatim - summarize.",
+ "role": "system",
+ "name": "agents_test-assessor_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "description": "recreates the exact request that was sent to openai for the last request, as well as the response back from openai. Returns the last request exactly as it was sent to the OpenAI api, and the response from the OpenAI api.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "threadPath": {
+ "type": "string",
+ "description": "relative path to the thread to recreate the request response pair from"
+ }
+ },
+ "required": [
+ "threadPath"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "description": "The assessment outcome of a single test iteration, including reasoning, analysis, and improvements",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the chain of thought reasoning for how the outcome was decided upon"
+ },
+ "outcome": {
+ "type": "boolean",
+ "description": "the outcome of the test iteration, true if the expectation was met, false if it was not"
+ },
+ "analysis": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the step by step analysis of WHY the system prompt of the target agent under test did NOT perform as well in the outcome as it could have"
+ },
+ "improvements": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the improvement(s) to the agent prompt that would have resulted in better performance to reach the outcome"
+ }
+ },
+ "required": [
+ "reasoning",
+ "outcome"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/test-assessor.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_KxjltrPqXKyk1fcK1OhhCMxi",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "arguments": "{\"reasoning\":[\"The local function was indeed called as indicated by the tool call in the response, which successfully executed and returned 'Local reply.'\",\"There were no errors or refusals, meaning the assistant functioned as intended in executing the call,\"],\"outcome\":true,\"analysis\":[],\"improvements\":[]}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384566,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 1033,
+ "openAiProcessingMs": 822,
+ "usage": {
+ "completion_tokens": 76,
+ "prompt_tokens": 964,
+ "total_tokens": 1040,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ],
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV/case_1/iteration_0": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "call the local function",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_TrqXpjurgn77TXzAtjLUw3lF"
+ },
+ {
+ "role": "assistant",
+ "content": "Local reply.",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the local function",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/agent-fixture.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_bmk6SePr9Zb7gPQDboQKMt2I",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384569,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 479,
+ "openAiProcessingMs": 276,
+ "usage": {
+ "completion_tokens": 12,
+ "prompt_tokens": 142,
+ "total_tokens": 154,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "auto",
+ "parallel_tool_calls": true,
+ "messages": [
+ {
+ "content": "call the local function",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_TrqXpjurgn77TXzAtjLUw3lF",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_TrqXpjurgn77TXzAtjLUw3lF"
+ },
+ {
+ "role": "assistant",
+ "content": "Local reply.",
+ "name": "agents_agent-fixture_md",
+ "refusal": null
+ },
+ {
+ "content": "call the local function",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_agent-fixture_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_bmk6SePr9Zb7gPQDboQKMt2I",
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "arguments": "{}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "local reply",
+ "tool_call_id": "call_bmk6SePr9Zb7gPQDboQKMt2I"
+ },
+ {
+ "content": "Your name is 'Assistant'\n\nALWAYS be as brief as possible",
+ "role": "system",
+ "name": "agents_agent-fixture_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_local",
+ "description": "ping locally",
+ "parameters": {
+ "type": "object",
+ "properties": {},
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "io-fixture_error",
+ "description": "throw an error",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "message"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": "Local reply.",
+ "name": "agents/agent-fixture.md",
+ "refusal": null
+ },
+ "stats": {
+ "created": 1729384570,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 391,
+ "openAiProcessingMs": 185,
+ "usage": {
+ "completion_tokens": 4,
+ "prompt_tokens": 172,
+ "total_tokens": 176,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ],
+ "rep_E8R/dreamcatcher-tech/HAL:main/act_H2R/bac_VWV/case_1/iteration_0/assess_0": [
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "threadPath: threads/bac_VWVY702R0N37T6HC/case_1/iteration_0.json\n\nExpectation: function was called twice",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "content": "You are an expert assessor of test results.\n\nAI agents will have been run previously under test conditions. Your job is to\nassess the resulting system state against the expectation, analyze why the\nsystem prompt used for the AI agent did not perform as well as it could have,\nand list improvements that could be made to the system prompt.\n\nYou will be given two inputs:\n\n1. \"threadPath\" which is a parameter to call the openai function which will read\n in the system state for assessment against the expectation\n2. An \"Expectation\" to assess the system state against\n\nThe result from the openai function will be a json object with two keys: request\nand response. The request is the api call that was sent to the openai chat\ncompletion endpoint, and the response is what was received back from that api\ncall. Included in this api call will be the system prompt message.\n\nWhen considering the system prompt, look for factual inconsistencies,\nconflicting instructions, overly verbose or redundant sections. Also look for\nways to compress the prompt down to be more direct, or ways to make the prompt\nmore explicit to reduce the chances of deviation.\n\n## The process\n\nThere are only two steps you are allowed to do to complete your task:\n\nFirst, use the test-case-runner:openai function to read the thread file specified by threadPath. Think carefully about the information you receive\nback.\n\nSecond, analyze the information and then call the test-case-runner:assessment function with your assessment. Be brief - do not\nrepeat the expectation or the contents of the thread file verbatim - summarize.",
+ "role": "system",
+ "name": "agents_test-assessor_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "description": "recreates the exact request that was sent to openai for the last request, as well as the response back from openai. Returns the last request exactly as it was sent to the OpenAI api, and the response from the OpenAI api.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "threadPath": {
+ "type": "string",
+ "description": "relative path to the thread to recreate the request response pair from"
+ }
+ },
+ "required": [
+ "threadPath"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "description": "The assessment outcome of a single test iteration, including reasoning, analysis, and improvements",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the chain of thought reasoning for how the outcome was decided upon"
+ },
+ "outcome": {
+ "type": "boolean",
+ "description": "the outcome of the test iteration, true if the expectation was met, false if it was not"
+ },
+ "analysis": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the step by step analysis of WHY the system prompt of the target agent under test did NOT perform as well in the outcome as it could have"
+ },
+ "improvements": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the improvement(s) to the agent prompt that would have resulted in better performance to reach the outcome"
+ }
+ },
+ "required": [
+ "reasoning",
+ "outcome"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/test-assessor.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_RNUwMprBlEPjxJ1BbrSMYv8J",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384572,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 759,
+ "openAiProcessingMs": 557,
+ "usage": {
+ "completion_tokens": 41,
+ "prompt_tokens": 618,
+ "total_tokens": 659,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "threadPath: threads/bac_VWVY702R0N37T6HC/case_1/iteration_0.json\n\nExpectation: function was called twice",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_test-assessor_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_RNUwMprBlEPjxJ1BbrSMYv8J",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json.\"}",
+ "tool_call_id": "call_RNUwMprBlEPjxJ1BbrSMYv8J"
+ },
+ {
+ "content": "You are an expert assessor of test results.\n\nAI agents will have been run previously under test conditions. Your job is to\nassess the resulting system state against the expectation, analyze why the\nsystem prompt used for the AI agent did not perform as well as it could have,\nand list improvements that could be made to the system prompt.\n\nYou will be given two inputs:\n\n1. \"threadPath\" which is a parameter to call the openai function which will read\n in the system state for assessment against the expectation\n2. An \"Expectation\" to assess the system state against\n\nThe result from the openai function will be a json object with two keys: request\nand response. The request is the api call that was sent to the openai chat\ncompletion endpoint, and the response is what was received back from that api\ncall. Included in this api call will be the system prompt message.\n\nWhen considering the system prompt, look for factual inconsistencies,\nconflicting instructions, overly verbose or redundant sections. Also look for\nways to compress the prompt down to be more direct, or ways to make the prompt\nmore explicit to reduce the chances of deviation.\n\n## The process\n\nThere are only two steps you are allowed to do to complete your task:\n\nFirst, use the test-case-runner:openai function to read the thread file specified by threadPath. Think carefully about the information you receive\nback.\n\nSecond, analyze the information and then call the test-case-runner:assessment function with your assessment. Be brief - do not\nrepeat the expectation or the contents of the thread file verbatim - summarize.",
+ "role": "system",
+ "name": "agents_test-assessor_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "description": "recreates the exact request that was sent to openai for the last request, as well as the response back from openai. Returns the last request exactly as it was sent to the OpenAI api, and the response from the OpenAI api.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "threadPath": {
+ "type": "string",
+ "description": "relative path to the thread to recreate the request response pair from"
+ }
+ },
+ "required": [
+ "threadPath"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "description": "The assessment outcome of a single test iteration, including reasoning, analysis, and improvements",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the chain of thought reasoning for how the outcome was decided upon"
+ },
+ "outcome": {
+ "type": "boolean",
+ "description": "the outcome of the test iteration, true if the expectation was met, false if it was not"
+ },
+ "analysis": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the step by step analysis of WHY the system prompt of the target agent under test did NOT perform as well in the outcome as it could have"
+ },
+ "improvements": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the improvement(s) to the agent prompt that would have resulted in better performance to reach the outcome"
+ }
+ },
+ "required": [
+ "reasoning",
+ "outcome"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/test-assessor.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_u9ztosQXfAk2PtX0U5Qm90N0",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VWVY702R0N37T6HC/case_1/iteration_0.json\"}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384574,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 832,
+ "openAiProcessingMs": 619,
+ "usage": {
+ "completion_tokens": 41,
+ "prompt_tokens": 749,
+ "total_tokens": 790,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ },
+ {
+ "request": {
+ "model": "gpt-4o-mini",
+ "tool_choice": "required",
+ "parallel_tool_calls": false,
+ "messages": [
+ {
+ "content": "threadPath: threads/bac_VWVY702R0N37T6HC/case_1/iteration_0.json\n\nExpectation: function was called twice",
+ "role": "user",
+ "name": "iteration_0"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_test-assessor_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_RNUwMprBlEPjxJ1BbrSMYv8J",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"code\":\"NotFoundError\",\"data\":{\"what\":\"threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json\"},\"caller\":\"\",\"name\":\"Error\",\"message\":\"Could not find threads/bac_VVWY702R0N37T6HC/case_1/iteration_0.json.\"}",
+ "tool_call_id": "call_RNUwMprBlEPjxJ1BbrSMYv8J"
+ },
+ {
+ "role": "assistant",
+ "content": null,
+ "name": "agents_test-assessor_md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_u9ztosQXfAk2PtX0U5Qm90N0",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "arguments": "{\"threadPath\":\"threads/bac_VWVY702R0N37T6HC/case_1/iteration_0.json\"}"
+ }
+ }
+ ]
+ },
+ {
+ "role": "tool",
+ "content": "{\"request\":{\"model\":\"gpt-4o-mini\",\"messages\":[{\"content\":\"call the local function\",\"role\":\"user\",\"name\":\"iteration_0\"},{\"role\":\"assistant\",\"content\":null,\"name\":\"agents_agent-fixture_md\",\"refusal\":null,\"tool_calls\":[{\"id\":\"call_TrqXpjurgn77TXzAtjLUw3lF\",\"type\":\"function\",\"function\":{\"name\":\"io-fixture_local\",\"arguments\":\"{}\"}}]},{\"role\":\"tool\",\"content\":\"local reply\",\"tool_call_id\":\"call_TrqXpjurgn77TXzAtjLUw3lF\"},{\"role\":\"assistant\",\"content\":\"Local reply.\",\"name\":\"agents_agent-fixture_md\",\"refusal\":null},{\"content\":\"call the local function\",\"role\":\"user\",\"name\":\"iteration_0\"},{\"role\":\"assistant\",\"content\":null,\"name\":\"agents_agent-fixture_md\",\"refusal\":null,\"tool_calls\":[{\"id\":\"call_bmk6SePr9Zb7gPQDboQKMt2I\",\"type\":\"function\",\"function\":{\"name\":\"io-fixture_local\",\"arguments\":\"{}\"}}]},{\"role\":\"tool\",\"content\":\"local reply\",\"tool_call_id\":\"call_bmk6SePr9Zb7gPQDboQKMt2I\"},{\"role\":\"system\",\"content\":\"Your name is 'Assistant'\\n\\nALWAYS be as brief as possible\",\"name\":\"agents_agent-fixture_md\"}],\"seed\":1337,\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"io-fixture_local\",\"description\":\"ping locally\",\"strict\":false,\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}},{\"type\":\"function\",\"function\":{\"name\":\"io-fixture_error\",\"description\":\"throw an error\",\"strict\":false,\"parameters\":{\"type\":\"object\",\"properties\":{\"message\":{\"type\":\"string\"}},\"required\":[\"message\"],\"additionalProperties\":false}}}],\"tool_choice\":\"auto\",\"parallel_tool_calls\":true},\"response\":{\"role\":\"assistant\",\"content\":\"Local reply.\",\"name\":\"agents/agent-fixture.md\",\"refusal\":null}}",
+ "tool_call_id": "call_u9ztosQXfAk2PtX0U5Qm90N0"
+ },
+ {
+ "content": "You are an expert assessor of test results.\n\nAI agents will have been run previously under test conditions. Your job is to\nassess the resulting system state against the expectation, analyze why the\nsystem prompt used for the AI agent did not perform as well as it could have,\nand list improvements that could be made to the system prompt.\n\nYou will be given two inputs:\n\n1. \"threadPath\" which is a parameter to call the openai function which will read\n in the system state for assessment against the expectation\n2. An \"Expectation\" to assess the system state against\n\nThe result from the openai function will be a json object with two keys: request\nand response. The request is the api call that was sent to the openai chat\ncompletion endpoint, and the response is what was received back from that api\ncall. Included in this api call will be the system prompt message.\n\nWhen considering the system prompt, look for factual inconsistencies,\nconflicting instructions, overly verbose or redundant sections. Also look for\nways to compress the prompt down to be more direct, or ways to make the prompt\nmore explicit to reduce the chances of deviation.\n\n## The process\n\nThere are only two steps you are allowed to do to complete your task:\n\nFirst, use the test-case-runner:openai function to read the thread file specified by threadPath. Think carefully about the information you receive\nback.\n\nSecond, analyze the information and then call the test-case-runner:assessment function with your assessment. Be brief - do not\nrepeat the expectation or the contents of the thread file verbatim - summarize.",
+ "role": "system",
+ "name": "agents_test-assessor_md"
+ }
+ ],
+ "seed": 1337,
+ "tools": [
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_openai",
+ "description": "recreates the exact request that was sent to openai for the last request, as well as the response back from openai. Returns the last request exactly as it was sent to the OpenAI api, and the response from the OpenAI api.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "threadPath": {
+ "type": "string",
+ "description": "relative path to the thread to recreate the request response pair from"
+ }
+ },
+ "required": [
+ "threadPath"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "description": "The assessment outcome of a single test iteration, including reasoning, analysis, and improvements",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "reasoning": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the chain of thought reasoning for how the outcome was decided upon"
+ },
+ "outcome": {
+ "type": "boolean",
+ "description": "the outcome of the test iteration, true if the expectation was met, false if it was not"
+ },
+ "analysis": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the step by step analysis of WHY the system prompt of the target agent under test did NOT perform as well in the outcome as it could have"
+ },
+ "improvements": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "the improvement(s) to the agent prompt that would have resulted in better performance to reach the outcome"
+ }
+ },
+ "required": [
+ "reasoning",
+ "outcome"
+ ],
+ "additionalProperties": false
+ },
+ "strict": false
+ }
+ }
+ ]
+ },
+ "reply": {
+ "assistant": {
+ "role": "assistant",
+ "content": null,
+ "name": "agents/test-assessor.md",
+ "refusal": null,
+ "tool_calls": [
+ {
+ "id": "call_93wgP7ueuMuCSc90esYfpqup",
+ "type": "function",
+ "function": {
+ "name": "test-case-runner_assessment",
+ "arguments": "{\"reasoning\":[\"The function was called twice as per the expectation.\",\"The response from the system indicates that it successfully executed the local function on both calls.\"],\"outcome\":true}"
+ }
+ }
+ ]
+ },
+ "stats": {
+ "created": 1729384575,
+ "model": "gpt-4o-mini-2024-07-18",
+ "system_fingerprint": "fp_482c22a7bc",
+ "duration": 875,
+ "openAiProcessingMs": 654,
+ "usage": {
+ "completion_tokens": 50,
+ "prompt_tokens": 1236,
+ "total_tokens": 1286,
+ "completion_tokens_details": {
+ "reasoning_tokens": 0
+ },
+ "prompt_tokens_details": {
+ "cached_tokens": 0
+ }
+ }
+ }
+ }
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/_import-artifact/isolates/actor.ts b/_import-artifact/isolates/actor.ts
new file mode 100644
index 000000000000..868b635d97d4
--- /dev/null
+++ b/_import-artifact/isolates/actor.ts
@@ -0,0 +1,164 @@
+import { z } from 'zod'
+import * as backchat from './backchat.ts'
+import * as longthread from './longthread.ts'
+import * as system from './system.ts'
+import {
+ addBranches,
+ Functions,
+ getParent,
+ type IA,
+ isActorBranch,
+ machineIdRegex,
+ pidSchema,
+ print,
+ RpcOpts,
+} from '@/constants.ts'
+import * as actor from '@/api/isolates/actor.ts'
+import { assert, Debug, equal } from '@utils'
+
+const log = Debug('AI:actor')
+
+export const parameters = actor.parameters
+export const returns = actor.returns
+
+export const functions: Functions = {
+ async backchat({ backchatId, machineId }, api) {
+ assert(isActorBranch(api.pid), 'Not actor branch: ' + print(api.pid))
+
+ log('backchat', print(api.pid))
+ const isNewActor = !!machineId
+ if (isNewActor) {
+ await api.updateState(() => {
+ return { machines: { [machineId]: { access: [] } }, repos: {} }
+ }, stateSchema)
+ }
+ const opts: RpcOpts = {
+ noClose: true,
+ branchName: backchatId,
+ }
+
+ const { mergeInternal } = await api.actions('system')
+ const from = getParent(api.pid)
+ const { elapsed } = await mergeInternal({ from, to: api.pid })
+ log('mergeInternal lasted', elapsed)
+
+ const { newThread } = await api.actions('backchat', opts)
+ // TODO set permissions on .io.json
+ await newThread({})
+ // TODO optionally start a default thread
+ const pid = addBranches(api.pid, backchatId)
+ log('backchat pid', print(pid))
+ return pid
+ },
+ async thread({ threadId }, api) {
+ const opts = { branchName: threadId, noClose: true }
+ const actions = await api.actions('longthread', opts)
+ await actions.start({})
+ return addBranches(api.pid, threadId)
+ },
+ rm: async ({ repo, all = false }, api) => {
+ assert(isActorBranch(api.pid), 'rm not actor: ' + print(api.pid))
+ log('rm', repo, all)
+
+ const { rm } = await api.actions('system')
+ const state = await api.state(stateSchema, bare)
+ if (all) {
+ const promises = []
+ for (const repo in state.repos) {
+ promises.push(rm({ pid: state.repos[repo] }))
+ }
+ await Promise.all(promises)
+ await api.updateState(
+ ({ machines, repos }) => {
+ assert(equal(state.repos, repos), 'repos changed')
+ return { machines, repos: {} }
+ },
+ stateSchema,
+ )
+ return { reposDeleted: promises.length }
+ }
+ assert(repo, 'must specify repo or all')
+ if (!(repo in state.repos)) {
+ return { reposDeleted: 0 }
+ }
+ const pid = state.repos[repo]
+ log('rm', repo, print(pid), all)
+
+ await rm({ pid })
+ await api.updateState(({ machines, repos }) => {
+ assert(equal(state.repos, repos), 'repos changed')
+ delete repos[repo]
+ return { machines, repos }
+ }, stateSchema)
+ return { reposDeleted: 1 }
+ },
+ lsRepos: async (_, api) => {
+ assert(isActorBranch(api.pid), 'lsRepos not actor: ' + print(api.pid))
+ const { repos } = await api.state(stateSchema, bare)
+ return Object.keys(repos)
+ },
+ clone: async ({ repo, isolate, params }, api) => {
+ assert(isActorBranch(api.pid), 'clone not actor: ' + print(api.pid))
+ log('clone', repo, isolate, params)
+
+ await assertNoRepo(api, repo)
+
+ const { clone } = await api.actions('system')
+ const result = await clone({ repo, isolate, params })
+ log('clone result', print(result.pid))
+
+ log('state', await api.state(stateSchema, bare))
+
+ await api.updateState(({ machines, repos }) => {
+ assert(!repos[repo], 'repos changed: ' + repo)
+ repos[repo] = result.pid
+ return { machines, repos }
+ }, stateSchema)
+ log('state', await api.state(stateSchema, bare))
+ return result
+ },
+ init: async ({ repo, isolate, params }, api) => {
+ assert(isActorBranch(api.pid), 'init not actor: ' + print(api.pid))
+ log('init', repo, isolate, params)
+
+ await assertNoRepo(api, repo)
+
+ const { init } = await api.actions('system')
+ const { pid, head } = await init({ repo, isolate, params })
+
+ await api.updateState(({ machines, repos }) => {
+ assert(!repos[repo], 'repos changed: ' + repo)
+ repos[repo] = pid
+ return { machines, repos }
+ }, stateSchema)
+ return { pid, head }
+ },
+ pull: async ({ repo, target }, api) => {
+ assert(isActorBranch(api.pid), 'pull not actor: ' + print(api.pid))
+ log('pull', repo, print(target))
+ target = target || api.pid
+
+ const { pull } = await api.actions('system')
+ const { head, elapsed } = await pull({ repo, target })
+ return { head, elapsed, pid: target }
+ },
+}
+const assertNoRepo = async (api: IA, repo: string) => {
+ const state = await api.state(stateSchema, bare)
+ if (repo in state.repos) {
+ throw new Error('Repo already exists: ' + repo)
+ }
+}
+
+const stateSchema = z.object({
+ repos: z.record(pidSchema),
+ machines: z.record(
+ z.string().regex(machineIdRegex),
+ z.object({
+ /** Log when a machine does something */
+ access: z.array(z.string()),
+ }),
+ ),
+})
+
+const bare = { repos: {}, machines: {} }
diff --git a/_import-artifact/isolates/actors.ts b/_import-artifact/isolates/actors.ts
new file mode 100644
index 000000000000..f08739c4f5d8
--- /dev/null
+++ b/_import-artifact/isolates/actors.ts
@@ -0,0 +1,161 @@
+import {
+ actorIdRegex,
+ addBranches,
+ backchatIdRegex,
+ colorize,
+ Functions,
+ getActorId,
+ isBaseRepo,
+ machineIdRegex,
+ pidSchema,
+ print,
+ RpcOpts,
+ SU_ACTOR,
+ SU_BACKCHAT,
+ ToApiType,
+} from '@/constants.ts'
+import * as actor from '@/api/isolates/actor.ts'
+import { assert, Debug, expect } from '@utils'
+import * as session from './session.ts'
+import * as machines from './machines.ts'
+import { Crypto } from '../api/crypto.ts'
+import { z } from 'zod'
+
+const log = Debug('AI:actors')
+
+export const parameters = {
+ '@@install': z.object({
+ /** The superuser machine id */
+ superuser: z.string().regex(machineIdRegex),
+ }),
+ createActor: z.object({
+ actorId: z.string().regex(actorIdRegex),
+ machineId: z.string().regex(machineIdRegex),
+ backchatId: z.string().regex(backchatIdRegex),
+ }).describe(
+ 'Create a new actor branch and a new backchat branch, as well as writing the machineId to the "machines" branch and pointing it to the actor branch',
+ ),
+ /**
+ * Called by an actor, after authorizing, to merge its actorId with the
+ * actorId authorized with the given auth provider.
+ *
+ * For example, in github, the github user id is used to link actorIds
+ * together, and the first actorId to pass auth is the stable actorId for that
+ * user id, so future requests to merge always merge into that actorId.
+ *
+ * The operation leaves a record of what auth provider approved what
+ * unification and at what commit.
+ */
+ surrender: z.object({
+ authProvider: pidSchema,
+ }),
+ /**
+ * Register an auth provider that is allowed to authorize merging actorIds.
+ * Can only be called by the installation owner account.
+ */
+ addAuthProvider: z.object({
+ provider: pidSchema,
+ name: z.string(),
+ }),
+}
+export const returns = {
+ '@@install': z.void(),
+ createActor: pidSchema,
+ surrender: z.string(),
+ addAuthProvider: z.void(),
+}
+export type Api = ToApiType
+
+export const functions: Functions = {
+ async '@@install'({ superuser }, api) {
+ // TODO set ACL on io.json to only run this isolate
+ assert(Crypto.assert(superuser), 'invalid superuser: ' + superuser)
+ assert(isBaseRepo(api.pid), '@@install not base: ' + print(api.pid))
+ log('@@install', print(api.pid))
+
+ const children = await api.lsChildren()
+ expect(children, 'repo must have no child branches').toEqual([])
+
+ // TODO make a permissions branch based on the repoid, so it is unique
+ await api.updateState((state) => {
+ expect(state, 'state must be empty').toEqual({})
+ return { superuser, authProviders: {} }
+ }, stateSchema)
+
+ // TODO send an api action that wipes the dir and writes a basic commit
+ const { create } = await api.functions('session')
+ const { createActor } = await api.functions