@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/spec/hrpc/messages.js

@@ -144,7 +144,10 @@ const encoding4 = {
       (m.imageHeight ? 16384 : 0) |
       ((version >= 5 && m.approvalMode) ? 32768 : 0) |
       ((version >= 5 && m.disabledToolsets) ? 65536 : 0) |
-      ((version >= 10 && m.sandboxMode) ? 131072 : 0)
+      ((version >= 10 && m.sandboxMode) ? 131072 : 0) |
+      ((version >= 19 && m.handoffs) ? 262144 : 0) |
+      ((version >= 19 && m.plan) ? 524288 : 0) |
+      ((version >= 19 && m.model) ? 1048576 : 0)
 
     c.uint.preencode(state, flags)
 
@@ -165,6 +168,8 @@ const encoding4 = {
     if (m.imageHeight) c.uint.preencode(state, m.imageHeight)
     if (version >= 5 && m.approvalMode) encoding59.preencode(state, m.approvalMode)
     if (version >= 5 && m.disabledToolsets) encoding4_16.preencode(state, m.disabledToolsets)
+    if (version >= 19 && m.handoffs) encoding4_18.preencode(state, m.handoffs)
+    if (version >= 19 && m.model) c.string.preencode(state, m.model)
   },
   encode(state, m) {
     const flags =
@@ -185,7 +190,10 @@ const encoding4 = {
       (m.imageHeight ? 16384 : 0) |
       ((version >= 5 && m.approvalMode) ? 32768 : 0) |
       ((version >= 5 && m.disabledToolsets) ? 65536 : 0) |
-      ((version >= 10 && m.sandboxMode) ? 131072 : 0)
+      ((version >= 10 && m.sandboxMode) ? 131072 : 0) |
+      ((version >= 19 && m.handoffs) ? 262144 : 0) |
+      ((version >= 19 && m.plan) ? 524288 : 0) |
+      ((version >= 19 && m.model) ? 1048576 : 0)
 
     c.uint.encode(state, flags)
 
@@ -206,6 +214,8 @@ const encoding4 = {
     if (m.imageHeight) c.uint.encode(state, m.imageHeight)
     if (version >= 5 && m.approvalMode) encoding59.encode(state, m.approvalMode)
     if (version >= 5 && m.disabledToolsets) encoding4_16.encode(state, m.disabledToolsets)
+    if (version >= 19 && m.handoffs) encoding4_18.encode(state, m.handoffs)
+    if (version >= 19 && m.model) c.string.encode(state, m.model)
   },
   decode(state) {
     const flags = c.uint.decode(state)
@@ -228,7 +238,10 @@ const encoding4 = {
       imageHeight: (flags & 16384) !== 0 ? c.uint.decode(state) : 0,
       approvalMode: (version >= 5 && (flags & 32768) !== 0) ? encoding59.decode(state) : null,
       disabledToolsets: (version >= 5 && (flags & 65536) !== 0) ? encoding4_16.decode(state) : null,
-      sandboxMode: (version >= 10 && (flags & 131072) !== 0)
+      sandboxMode: (version >= 10 && (flags & 131072) !== 0),
+      handoffs: (version >= 19 && (flags & 262144) !== 0) ? encoding4_18.decode(state) : null,
+      plan: (version >= 19 && (flags & 524288) !== 0),
+      model: (version >= 19 && (flags & 1048576) !== 0) ? c.string.decode(state) : null
     }
   }
 }
@@ -303,18 +316,31 @@ const encoding7 = {
   preencode(state, m) {
     encoding5.preencode(state, m.role)
     c.string.preencode(state, m.content)
-    state.end++ // max flag is 1 so always one byte
+    state.end++ // max flag is 16 so always one byte
 
     if (m.attachments) encoding7_2.preencode(state, m.attachments)
+    if (version >= 19 && m.toolCalls) c.json.preencode(state, m.toolCalls)
+    if (version >= 19 && m.toolCallId) c.string.preencode(state, m.toolCallId)
+    if (version >= 19 && m.name) c.string.preencode(state, m.name)
+    if (version >= 19 && m.id) c.string.preencode(state, m.id)
   },
   encode(state, m) {
-    const flags = m.attachments ? 1 : 0
+    const flags =
+      (m.attachments ? 1 : 0) |
+      ((version >= 19 && m.toolCalls) ? 2 : 0) |
+      ((version >= 19 && m.toolCallId) ? 4 : 0) |
+      ((version >= 19 && m.name) ? 8 : 0) |
+      ((version >= 19 && m.id) ? 16 : 0)
 
     encoding5.encode(state, m.role)
     c.string.encode(state, m.content)
     c.uint.encode(state, flags)
 
     if (m.attachments) encoding7_2.encode(state, m.attachments)
+    if (version >= 19 && m.toolCalls) c.json.encode(state, m.toolCalls)
+    if (version >= 19 && m.toolCallId) c.string.encode(state, m.toolCallId)
+    if (version >= 19 && m.name) c.string.encode(state, m.name)
+    if (version >= 19 && m.id) c.string.encode(state, m.id)
   },
   decode(state) {
     const r0 = encoding5.decode(state)
@@ -324,7 +350,11 @@ const encoding7 = {
     return {
       role: r0,
       content: r1,
-      attachments: (flags & 1) !== 0 ? encoding7_2.decode(state) : null
+      attachments: (flags & 1) !== 0 ? encoding7_2.decode(state) : null,
+      toolCalls: (version >= 19 && (flags & 2) !== 0) ? c.json.decode(state) : null,
+      toolCallId: (version >= 19 && (flags & 4) !== 0) ? c.string.decode(state) : null,
+      name: (version >= 19 && (flags & 8) !== 0) ? c.string.decode(state) : null,
+      id: (version >= 19 && (flags & 16) !== 0) ? c.string.decode(state) : null
     }
   }
 }
@@ -389,13 +419,15 @@ const encoding10_enum = {
   "drive-result": 'drive-result',
   invoke: 'invoke',
   "run-log-result": 'run-log-result',
-  pause: 'pause'
+  pause: 'pause',
+  steer: 'steer',
+  "follow-up": 'follow-up'
 }
 
 // @harness/completion-frame-type enum
 const encoding10 = {
   preencode (state, m) {
-    state.end++ // max enum is 10 so always one byte
+    state.end++ // max enum is 12 so always one byte
   },
   encode (state, m) {
     switch (m) {
@@ -429,6 +461,12 @@ const encoding10 = {
       case 'pause':
         c.uint.encode(state, 10)
         break
+      case 'steer':
+        c.uint.encode(state, 11)
+        break
+      case 'follow-up':
+        c.uint.encode(state, 12)
+        break
       default:
         throw new Error('Unknown enum')
     }
@@ -455,6 +493,10 @@ const encoding10 = {
         return 'run-log-result'
       case 10:
         return 'pause'
+      case 11:
+        return 'steer'
+      case 12:
+        return 'follow-up'
       default: return null
     }
   }
@@ -504,7 +546,8 @@ const encoding11 = {
       ((version >= 11 && m.capability) ? 67108864 : 0) |
       ((version >= 11 && m.arguments) ? 134217728 : 0) |
       ((version >= 12 && m.enhance) ? 268435456 : 0) |
-      ((version >= 19 && m.runId) ? 536870912 : 0)
+      ((version >= 19 && m.runId) ? 536870912 : 0) |
+      ((version >= 19 && m.maxToolRounds) ? 1073741824 : 0)
 
     encoding10.preencode(state, m.type)
     c.uint.preencode(state, flags)
@@ -536,6 +579,7 @@ const encoding11 = {
     if (version >= 11 && m.arguments) c.json.preencode(state, m.arguments)
     if (version >= 12 && m.enhance) c.string.preencode(state, m.enhance)
     if (version >= 19 && m.runId) c.string.preencode(state, m.runId)
+    if (version >= 19 && m.maxToolRounds) c.uint.preencode(state, m.maxToolRounds)
   },
   encode(state, m) {
     const flags =
@@ -568,7 +612,8 @@ const encoding11 = {
       ((version >= 11 && m.capability) ? 67108864 : 0) |
       ((version >= 11 && m.arguments) ? 134217728 : 0) |
       ((version >= 12 && m.enhance) ? 268435456 : 0) |
-      ((version >= 19 && m.runId) ? 536870912 : 0)
+      ((version >= 19 && m.runId) ? 536870912 : 0) |
+      ((version >= 19 && m.maxToolRounds) ? 1073741824 : 0)
 
     encoding10.encode(state, m.type)
     c.uint.encode(state, flags)
@@ -600,6 +645,7 @@ const encoding11 = {
     if (version >= 11 && m.arguments) c.json.encode(state, m.arguments)
     if (version >= 12 && m.enhance) c.string.encode(state, m.enhance)
     if (version >= 19 && m.runId) c.string.encode(state, m.runId)
+    if (version >= 19 && m.maxToolRounds) c.uint.encode(state, m.maxToolRounds)
   },
   decode(state) {
     const r0 = encoding10.decode(state)
@@ -636,7 +682,8 @@ const encoding11 = {
       capability: (version >= 11 && (flags & 67108864) !== 0) ? c.string.decode(state) : null,
       arguments: (version >= 11 && (flags & 134217728) !== 0) ? c.json.decode(state) : null,
       enhance: (version >= 12 && (flags & 268435456) !== 0) ? c.string.decode(state) : null,
-      runId: (version >= 19 && (flags & 536870912) !== 0) ? c.string.decode(state) : null
+      runId: (version >= 19 && (flags & 536870912) !== 0) ? c.string.decode(state) : null,
+      maxToolRounds: (version >= 19 && (flags & 1073741824) !== 0) ? c.uint.decode(state) : 0
     }
   }
 }
@@ -665,13 +712,17 @@ const encoding12_enum = {
   paused: 'paused',
   "recovery-required": 'recovery-required',
   "round-reset": 'round-reset',
-  "run-log-append": 'run-log-append'
+  "run-log-append": 'run-log-append',
+  input: 'input',
+  goal: 'goal',
+  fold: 'fold',
+  "input-rejected": 'input-rejected'
 }
 
 // @harness/completion-event-type enum
 const encoding12 = {
   preencode (state, m) {
-    state.end++ // max enum is 24 so always one byte
+    state.end++ // max enum is 28 so always one byte
   },
   encode (state, m) {
     switch (m) {
@@ -747,6 +798,18 @@ const encoding12 = {
       case 'run-log-append':
         c.uint.encode(state, 24)
         break
+      case 'input':
+        c.uint.encode(state, 25)
+        break
+      case 'goal':
+        c.uint.encode(state, 26)
+        break
+      case 'fold':
+        c.uint.encode(state, 27)
+        break
+      case 'input-rejected':
+        c.uint.encode(state, 28)
+        break
       default:
         throw new Error('Unknown enum')
     }
@@ -801,6 +864,14 @@ const encoding12 = {
         return 'round-reset'
       case 24:
         return 'run-log-append'
+      case 25:
+        return 'input'
+      case 26:
+        return 'goal'
+      case 27:
+        return 'fold'
+      case 28:
+        return 'input-rejected'
       default: return null
     }
   }
@@ -1049,18 +1120,28 @@ const encoding15 = {
   preencode(state, m) {
     c.string.preencode(state, m.model)
     c.uint.preencode(state, m.refs)
+    state.end++ // max flag is 1 so always one byte
+
+    if (version >= 19 && m.fit) encoding15_2.preencode(state, m.fit)
   },
   encode(state, m) {
+    const flags = (version >= 19 && m.fit) ? 1 : 0
+
     c.string.encode(state, m.model)
     c.uint.encode(state, m.refs)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.fit) encoding15_2.encode(state, m.fit)
   },
   decode(state) {
     const r0 = c.string.decode(state)
     const r1 = c.uint.decode(state)
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
 
     return {
       model: r0,
-      refs: r1
+      refs: r1,
+      fit: (version >= 19 && (flags & 1) !== 0) ? encoding15_2.decode(state) : null
     }
   }
 }
@@ -1676,15 +1757,29 @@ const encoding30 = {
 // @harness/model-info
 const encoding31 = {
   preencode(state, m) {
+    const flags =
+      (m.isCached ? 1 : 0) |
+      (m.isLoaded ? 2 : 0) |
+      (m.supportsImages ? 4 : 0) |
+      (m.actualSize ? 8 : 0) |
+      ((version >= 15 && m.label) ? 16 : 0) |
+      ((version >= 18 && m.isLoading) ? 32 : 0) |
+      ((version >= 19 && m.fit) ? 64 : 0) |
+      ((version >= 19 && m.fitBasis) ? 128 : 0) |
+      ((version >= 19 && m.fitEvidence) ? 256 : 0)
+
     c.string.preencode(state, m.name)
     c.string.preencode(state, m.type)
     c.string.preencode(state, m.registryPath)
     c.string.preencode(state, m.registrySource)
-    state.end++ // max flag is 32 so always one byte
+    c.uint.preencode(state, flags)
     c.uint.preencode(state, m.expectedSize)
 
     if (m.actualSize) c.uint.preencode(state, m.actualSize)
     if (version >= 15 && m.label) c.string.preencode(state, m.label)
+    if (version >= 19 && m.fit) c.string.preencode(state, m.fit)
+    if (version >= 19 && m.fitBasis) c.string.preencode(state, m.fitBasis)
+    if (version >= 19 && m.fitEvidence) c.string.preencode(state, m.fitEvidence)
   },
   encode(state, m) {
     const flags =
@@ -1693,7 +1788,10 @@ const encoding31 = {
       (m.supportsImages ? 4 : 0) |
       (m.actualSize ? 8 : 0) |
       ((version >= 15 && m.label) ? 16 : 0) |
-      ((version >= 18 && m.isLoading) ? 32 : 0)
+      ((version >= 18 && m.isLoading) ? 32 : 0) |
+      ((version >= 19 && m.fit) ? 64 : 0) |
+      ((version >= 19 && m.fitBasis) ? 128 : 0) |
+      ((version >= 19 && m.fitEvidence) ? 256 : 0)
 
     c.string.encode(state, m.name)
     c.string.encode(state, m.type)
@@ -1704,6 +1802,9 @@ const encoding31 = {
 
     if (m.actualSize) c.uint.encode(state, m.actualSize)
     if (version >= 15 && m.label) c.string.encode(state, m.label)
+    if (version >= 19 && m.fit) c.string.encode(state, m.fit)
+    if (version >= 19 && m.fitBasis) c.string.encode(state, m.fitBasis)
+    if (version >= 19 && m.fitEvidence) c.string.encode(state, m.fitEvidence)
   },
   decode(state) {
     const r0 = c.string.decode(state)
@@ -1723,7 +1824,10 @@ const encoding31 = {
       expectedSize: c.uint.decode(state),
       actualSize: (flags & 8) !== 0 ? c.uint.decode(state) : 0,
       label: (version >= 15 && (flags & 16) !== 0) ? c.string.decode(state) : null,
-      isLoading: (version >= 18 && (flags & 32) !== 0)
+      isLoading: (version >= 18 && (flags & 32) !== 0),
+      fit: (version >= 19 && (flags & 64) !== 0) ? c.string.decode(state) : null,
+      fitBasis: (version >= 19 && (flags & 128) !== 0) ? c.string.decode(state) : null,
+      fitEvidence: (version >= 19 && (flags & 256) !== 0) ? c.string.decode(state) : null
     }
   }
 }
@@ -3508,8 +3612,452 @@ const encoding91 = {
   }
 }
 
+// @harness/agent-handoff
+const encoding92 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.id)
+    c.string.preencode(state, m.description)
+  },
+  encode(state, m) {
+    c.string.encode(state, m.id)
+    c.string.encode(state, m.description)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = c.string.decode(state)
+
+    return {
+      id: r0,
+      description: r1
+    }
+  }
+}
+
+const encoding93_enum = {
+  fit: 'fit',
+  "does-not-fit": 'does-not-fit',
+  unknown: 'unknown'
+}
+
+// @harness/load-fit-verdict enum
+const encoding93 = {
+  preencode (state, m) {
+    state.end++ // max enum is 3 so always one byte
+  },
+  encode (state, m) {
+    switch (m) {
+      case 'fit':
+        c.uint.encode(state, 1)
+        break
+      case 'does-not-fit':
+        c.uint.encode(state, 2)
+        break
+      case 'unknown':
+        c.uint.encode(state, 3)
+        break
+      default:
+        throw new Error('Unknown enum')
+    }
+  },
+  decode (state) {
+    switch (c.uint.decode(state)) {
+      case 1:
+        return 'fit'
+      case 2:
+        return 'does-not-fit'
+      case 3:
+        return 'unknown'
+      default: return null
+    }
+  }
+}
+
+// @harness/load-fit-plan
+const encoding94 = {
+  preencode(state, m) {
+    c.int.preencode(state, m.nCtx)
+    c.int.preencode(state, m.nGpuLayers)
+    c.int.preencode(state, m.nGpuDevices)
+  },
+  encode(state, m) {
+    c.int.encode(state, m.nCtx)
+    c.int.encode(state, m.nGpuLayers)
+    c.int.encode(state, m.nGpuDevices)
+  },
+  decode(state) {
+    const r0 = c.int.decode(state)
+    const r1 = c.int.decode(state)
+    const r2 = c.int.decode(state)
+
+    return {
+      nCtx: r0,
+      nGpuLayers: r1,
+      nGpuDevices: r2
+    }
+  }
+}
+
+// @harness/load-fit.plan
+const encoding95_2 = c.frame(encoding94)
+
+// @harness/load-fit
+const encoding95 = {
+  preencode(state, m) {
+    encoding93.preencode(state, m.verdict)
+    c.string.preencode(state, m.reason)
+    state.end++ // max flag is 4 so always one byte
+
+    if (version >= 19 && m.plan) encoding95_2.preencode(state, m.plan)
+    if (version >= 19 && m.deviceBytes) c.float64.preencode(state, m.deviceBytes)
+    if (version >= 19 && m.hostBytes) c.float64.preencode(state, m.hostBytes)
+  },
+  encode(state, m) {
+    const flags =
+      ((version >= 19 && m.plan) ? 1 : 0) |
+      ((version >= 19 && m.deviceBytes) ? 2 : 0) |
+      ((version >= 19 && m.hostBytes) ? 4 : 0)
+
+    encoding93.encode(state, m.verdict)
+    c.string.encode(state, m.reason)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.plan) encoding95_2.encode(state, m.plan)
+    if (version >= 19 && m.deviceBytes) c.float64.encode(state, m.deviceBytes)
+    if (version >= 19 && m.hostBytes) c.float64.encode(state, m.hostBytes)
+  },
+  decode(state) {
+    const r0 = encoding93.decode(state)
+    const r1 = c.string.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      verdict: r0,
+      reason: r1,
+      plan: (version >= 19 && (flags & 1) !== 0) ? encoding95_2.decode(state) : null,
+      deviceBytes: (version >= 19 && (flags & 2) !== 0) ? c.float64.decode(state) : 0,
+      hostBytes: (version >= 19 && (flags & 4) !== 0) ? c.float64.decode(state) : 0
+    }
+  }
+}
+
+// @harness/knowledge-chunk
+const encoding96 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.id)
+    c.string.preencode(state, m.text)
+    state.end++ // max flag is 1 so always one byte
+
+    if (version >= 19 && m.metadata) c.json.preencode(state, m.metadata)
+  },
+  encode(state, m) {
+    const flags = (version >= 19 && m.metadata) ? 1 : 0
+
+    c.string.encode(state, m.id)
+    c.string.encode(state, m.text)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.metadata) c.json.encode(state, m.metadata)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = c.string.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      id: r0,
+      text: r1,
+      metadata: (version >= 19 && (flags & 1) !== 0) ? c.json.decode(state) : null
+    }
+  }
+}
+
+// @harness/knowledge-upsert-request.chunks
+const encoding97_3 = c.array(c.frame(encoding96))
+
+// @harness/knowledge-upsert-request
+const encoding97 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.artifactId)
+    state.end++ // max flag is 8 so always one byte
+
+    if (version >= 19 && m.version) c.string.preencode(state, m.version)
+    c.string.preencode(state, m.scope)
+    encoding97_3.preencode(state, m.chunks)
+    if (version >= 19 && m.model) c.string.preencode(state, m.model)
+    if (version >= 19 && m.dimensions) c.uint.preencode(state, m.dimensions)
+    if (version >= 19 && m.vectors) c.buffer.preencode(state, m.vectors)
+  },
+  encode(state, m) {
+    const flags =
+      ((version >= 19 && m.version) ? 1 : 0) |
+      ((version >= 19 && m.model) ? 2 : 0) |
+      ((version >= 19 && m.dimensions) ? 4 : 0) |
+      ((version >= 19 && m.vectors) ? 8 : 0)
+
+    c.string.encode(state, m.artifactId)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.version) c.string.encode(state, m.version)
+    c.string.encode(state, m.scope)
+    encoding97_3.encode(state, m.chunks)
+    if (version >= 19 && m.model) c.string.encode(state, m.model)
+    if (version >= 19 && m.dimensions) c.uint.encode(state, m.dimensions)
+    if (version >= 19 && m.vectors) c.buffer.encode(state, m.vectors)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      artifactId: r0,
+      version: (version >= 19 && (flags & 1) !== 0) ? c.string.decode(state) : null,
+      scope: c.string.decode(state),
+      chunks: encoding97_3.decode(state),
+      model: (version >= 19 && (flags & 2) !== 0) ? c.string.decode(state) : null,
+      dimensions: (version >= 19 && (flags & 4) !== 0) ? c.uint.decode(state) : 0,
+      vectors: (version >= 19 && (flags & 8) !== 0) ? c.buffer.decode(state) : null
+    }
+  }
+}
+
+// @harness/knowledge-upsert-response
+const encoding98 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.added)
+    state.end++ // max flag is 4 so always one byte
+
+    if (version >= 19 && m.model) c.string.preencode(state, m.model)
+    if (version >= 19 && m.dimensions) c.uint.preencode(state, m.dimensions)
+    if (version >= 19 && m.vectors) c.buffer.preencode(state, m.vectors)
+  },
+  encode(state, m) {
+    const flags =
+      ((version >= 19 && m.model) ? 1 : 0) |
+      ((version >= 19 && m.dimensions) ? 2 : 0) |
+      ((version >= 19 && m.vectors) ? 4 : 0)
+
+    c.uint.encode(state, m.added)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.model) c.string.encode(state, m.model)
+    if (version >= 19 && m.dimensions) c.uint.encode(state, m.dimensions)
+    if (version >= 19 && m.vectors) c.buffer.encode(state, m.vectors)
+  },
+  decode(state) {
+    const r0 = c.uint.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      added: r0,
+      model: (version >= 19 && (flags & 1) !== 0) ? c.string.decode(state) : null,
+      dimensions: (version >= 19 && (flags & 2) !== 0) ? c.uint.decode(state) : 0,
+      vectors: (version >= 19 && (flags & 4) !== 0) ? c.buffer.decode(state) : null
+    }
+  }
+}
+
+// @harness/knowledge-remove-request
+const encoding99 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.artifactId)
+  },
+  encode(state, m) {
+    c.string.encode(state, m.artifactId)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+
+    return {
+      artifactId: r0
+    }
+  }
+}
+
+// @harness/knowledge-remove-response
+const encoding100 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.removed)
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.removed)
+  },
+  decode(state) {
+    const r0 = c.uint.decode(state)
+
+    return {
+      removed: r0
+    }
+  }
+}
+
+// @harness/knowledge-search-request.scopes
+const encoding101_1 = encoding4_4
+
+// @harness/knowledge-search-request
+const encoding101 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.text)
+    encoding101_1.preencode(state, m.scopes)
+    state.end++ // max flag is 1 so always one byte
+
+    if (version >= 19 && m.k) c.uint.preencode(state, m.k)
+  },
+  encode(state, m) {
+    const flags = (version >= 19 && m.k) ? 1 : 0
+
+    c.string.encode(state, m.text)
+    encoding101_1.encode(state, m.scopes)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.k) c.uint.encode(state, m.k)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = encoding101_1.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      text: r0,
+      scopes: r1,
+      k: (version >= 19 && (flags & 1) !== 0) ? c.uint.decode(state) : 0
+    }
+  }
+}
+
+// @harness/knowledge-hit
+const encoding102 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.artifactId)
+    c.string.preencode(state, m.chunkId)
+    c.string.preencode(state, m.scope)
+    c.string.preencode(state, m.text)
+    c.float64.preencode(state, m.score)
+    state.end++ // max flag is 1 so always one byte
+
+    if (version >= 19 && m.metadata) c.json.preencode(state, m.metadata)
+  },
+  encode(state, m) {
+    const flags = (version >= 19 && m.metadata) ? 1 : 0
+
+    c.string.encode(state, m.artifactId)
+    c.string.encode(state, m.chunkId)
+    c.string.encode(state, m.scope)
+    c.string.encode(state, m.text)
+    c.float64.encode(state, m.score)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.metadata) c.json.encode(state, m.metadata)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = c.string.decode(state)
+    const r2 = c.string.decode(state)
+    const r3 = c.string.decode(state)
+    const r4 = c.float64.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      artifactId: r0,
+      chunkId: r1,
+      scope: r2,
+      text: r3,
+      score: r4,
+      metadata: (version >= 19 && (flags & 1) !== 0) ? c.json.decode(state) : null
+    }
+  }
+}
+
+// @harness/knowledge-search-response.hits
+const encoding103_0 = c.array(c.frame(encoding102))
+
+// @harness/knowledge-search-response
+const encoding103 = {
+  preencode(state, m) {
+    encoding103_0.preencode(state, m.hits)
+  },
+  encode(state, m) {
+    encoding103_0.encode(state, m.hits)
+  },
+  decode(state) {
+    const r0 = encoding103_0.decode(state)
+
+    return {
+      hits: r0
+    }
+  }
+}
+
+// @harness/knowledge-artifact-status
+const encoding104 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.artifactId)
+    state.end++ // max flag is 1 so always one byte
+
+    if (version >= 19 && m.version) c.string.preencode(state, m.version)
+    c.string.preencode(state, m.scope)
+    c.uint.preencode(state, m.chunks)
+  },
+  encode(state, m) {
+    const flags = (version >= 19 && m.version) ? 1 : 0
+
+    c.string.encode(state, m.artifactId)
+    c.uint.encode(state, flags)
+
+    if (version >= 19 && m.version) c.string.encode(state, m.version)
+    c.string.encode(state, m.scope)
+    c.uint.encode(state, m.chunks)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      artifactId: r0,
+      version: (version >= 19 && (flags & 1) !== 0) ? c.string.decode(state) : null,
+      scope: c.string.decode(state),
+      chunks: c.uint.decode(state)
+    }
+  }
+}
+
+// @harness/knowledge-status-response.artifacts
+const encoding105_3 = c.array(c.frame(encoding104))
+
+// @harness/knowledge-status-response
+const encoding105 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.model)
+    c.uint.preencode(state, m.dimensions)
+    c.uint.preencode(state, m.chunks)
+    encoding105_3.preencode(state, m.artifacts)
+  },
+  encode(state, m) {
+    c.string.encode(state, m.model)
+    c.uint.encode(state, m.dimensions)
+    c.uint.encode(state, m.chunks)
+    encoding105_3.encode(state, m.artifacts)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = c.uint.decode(state)
+    const r2 = c.uint.decode(state)
+    const r3 = encoding105_3.decode(state)
+
+    return {
+      model: r0,
+      dimensions: r1,
+      chunks: r2,
+      artifacts: r3
+    }
+  }
+}
+
+// @harness/agent-knobs.handoffs, deferred due to recusive use
+const encoding4_18 = c.array(c.frame(encoding92))
 // @harness/completion-frame.grantedDrives, deferred due to recusive use
 const encoding11_23 = c.array(c.frame(encoding60))
+// @harness/loaded-model.fit, deferred due to recusive use
+const encoding15_2 = c.frame(encoding95)
 // @harness/skill.setupV2, deferred due to recusive use
 const encoding28_14 = c.frame(encoding51)
 // @harness/capability-response.memoryBudget, deferred due to recusive use
@@ -3563,6 +4111,8 @@ function getEnum(name) {
       return encoding59_enum
     case '@harness/kv-cache-deletion-status':
       return encoding63_enum
+    case '@harness/load-fit-verdict':
+      return encoding93_enum
     default:
       throw new Error('Enum not found ' + name)
   }
@@ -3754,6 +4304,34 @@ function getEncoding(name) {
       return encoding90
     case '@harness/unload-model-response':
       return encoding91
+    case '@harness/agent-handoff':
+      return encoding92
+    case '@harness/load-fit-verdict':
+      return encoding93
+    case '@harness/load-fit-plan':
+      return encoding94
+    case '@harness/load-fit':
+      return encoding95
+    case '@harness/knowledge-chunk':
+      return encoding96
+    case '@harness/knowledge-upsert-request':
+      return encoding97
+    case '@harness/knowledge-upsert-response':
+      return encoding98
+    case '@harness/knowledge-remove-request':
+      return encoding99
+    case '@harness/knowledge-remove-response':
+      return encoding100
+    case '@harness/knowledge-search-request':
+      return encoding101
+    case '@harness/knowledge-hit':
+      return encoding102
+    case '@harness/knowledge-search-response':
+      return encoding103
+    case '@harness/knowledge-artifact-status':
+      return encoding104
+    case '@harness/knowledge-status-response':
+      return encoding105
     default:
       throw new Error('Encoder not found ' + name)
   }