beeai-framework 0.1.2

package/dist/agents/bee/runners/granite/prompts.d.ts

@@ -0,0 +1,145 @@
+import { PromptTemplate } from '../../../../template.js';
+import * as zod from 'zod';
+import '../../../../errors.js';
+import '../../../../internals/types.js';
+import '../../../../internals/helpers/guards.js';
+import '../../../../internals/serializable.js';
+import 'ajv';
+
+/**
+ * Copyright 2025 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+declare const GraniteBeeAssistantPrompt: PromptTemplate<zod.ZodObject<{
+    thought: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+    toolName: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+    toolInput: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+    toolOutput: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+    finalAnswer: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+}, "strip", zod.ZodTypeAny, {
+    toolName?: string[] | undefined;
+    thought?: string[] | undefined;
+    toolInput?: string[] | undefined;
+    toolOutput?: string[] | undefined;
+    finalAnswer?: string[] | undefined;
+}, {
+    toolName?: string[] | undefined;
+    thought?: string[] | undefined;
+    toolInput?: string[] | undefined;
+    toolOutput?: string[] | undefined;
+    finalAnswer?: string[] | undefined;
+}>>;
+declare const GraniteBeeSystemPrompt: PromptTemplate<zod.ZodObject<{
+    instructions: zod.ZodDefault<zod.ZodString>;
+    tools: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+        description: zod.ZodString;
+        schema: zod.ZodString;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        name: zod.ZodString;
+        description: zod.ZodString;
+        schema: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        name: zod.ZodString;
+        description: zod.ZodString;
+        schema: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">>, "many">;
+    createdAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+}, "strip", zod.ZodTypeAny, {
+    instructions: string;
+    tools: zod.objectOutputType<{
+        name: zod.ZodString;
+        description: zod.ZodString;
+        schema: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">[];
+    createdAt?: string | null | undefined;
+}, {
+    tools: zod.objectInputType<{
+        name: zod.ZodString;
+        description: zod.ZodString;
+        schema: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">[];
+    createdAt?: string | null | undefined;
+    instructions?: string | undefined;
+}>>;
+declare const GraniteBeeSchemaErrorPrompt: PromptTemplate<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+declare const GraniteBeeUserPrompt: PromptTemplate<zod.ZodObject<{
+    input: zod.ZodString;
+    meta: zod.ZodOptional<zod.ZodObject<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, zod.ZodTypeAny, "passthrough">>>;
+}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+    input: zod.ZodString;
+    meta: zod.ZodOptional<zod.ZodObject<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, zod.ZodTypeAny, "passthrough">>>;
+}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+    input: zod.ZodString;
+    meta: zod.ZodOptional<zod.ZodObject<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        createdAt: zod.ZodOptional<zod.ZodString>;
+    }, zod.ZodTypeAny, "passthrough">>>;
+}, zod.ZodTypeAny, "passthrough">>>;
+declare const GraniteBeeToolNotFoundPrompt: PromptTemplate<zod.ZodObject<{
+    tools: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        name: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        name: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">>, "many">;
+}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+    tools: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        name: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        name: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">>, "many">;
+}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+    tools: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+    }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+        name: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+        name: zod.ZodString;
+    }, zod.ZodTypeAny, "passthrough">>, "many">;
+}, zod.ZodTypeAny, "passthrough">>>;
+declare const GraniteBeeToolErrorPrompt: PromptTemplate<zod.ZodObject<{
+    reason: zod.ZodString;
+}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+    reason: zod.ZodString;
+}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+    reason: zod.ZodString;
+}, zod.ZodTypeAny, "passthrough">>>;
+declare const GraniteBeeToolInputErrorPrompt: PromptTemplate<zod.ZodObject<{
+    reason: zod.ZodString;
+}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+    reason: zod.ZodString;
+}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+    reason: zod.ZodString;
+}, zod.ZodTypeAny, "passthrough">>>;
+
+export { GraniteBeeAssistantPrompt, GraniteBeeSchemaErrorPrompt, GraniteBeeSystemPrompt, GraniteBeeToolErrorPrompt, GraniteBeeToolInputErrorPrompt, GraniteBeeToolNotFoundPrompt, GraniteBeeUserPrompt };

package/dist/agents/bee/runners/granite/prompts.js

@@ -0,0 +1,86 @@
+import { BeeAssistantPrompt, BeeSystemPrompt, BeeSchemaErrorPrompt, BeeUserPrompt, BeeToolNotFoundPrompt, BeeToolErrorPrompt, BeeToolInputErrorPrompt } from '../../prompts.js';
+
+const GraniteBeeAssistantPrompt = BeeAssistantPrompt.fork((config) => {
+  config.template = `{{#thought}}Thought: {{.}}
+{{/thought}}{{#toolName}}Tool Name: {{.}}
+{{/toolName}}{{#toolInput}}Tool Input: {{.}}
+{{/toolInput}}{{#finalAnswer}}Final Answer: {{.}}{{/finalAnswer}}`;
+});
+const GraniteBeeSystemPrompt = BeeSystemPrompt.fork((config) => {
+  config.defaults.instructions = "";
+  config.functions.formatDate = function() {
+    const date = this.createdAt ? new Date(this.createdAt) : /* @__PURE__ */ new Date();
+    return new Intl.DateTimeFormat("en-US", {
+      dateStyle: "full",
+      timeStyle: "medium"
+    }).format(date);
+  };
+  config.template = `You are an AI assistant.
+When the user sends a message figure out a solution and provide a final answer.
+{{#tools.length}}
+You have access to a set of tools that can be used to retrieve information and perform actions.
+Pay close attention to the tool description to determine if a tool is useful in a particular context.
+{{/tools.length}}
+
+# Communication structure
+You communicate only in instruction lines. Valid instruction lines are 'Thought' followed by 'Tool Name' and then 'Tool Input', or 'Thought' followed by 'Final Answer'
+
+Line starting 'Thought: ' The assistant's response always starts with a thought, this is a single line where the assistant thinks about the user's message and describes in detail what it should do next.
+{{#tools.length}}
+In a 'Thought: ', the assistant should determine if a Tool Call is necessary to get more information or perform an action, or if the available information is sufficient to provide the Final Answer.
+If a tool needs to be called and is available, the assistant will produce a tool call:
+Line starting 'Tool Name: ' name of the tool that you want to use.
+Line starting 'Tool Input: ' JSON formatted tool arguments adhering to the selected tool parameters schema i.e. {"arg1":"value1", "arg2":"value2"}.
+After a 'Tool Input: ' the next message will contain a tool response. The next output should be a 'Thought: ' where the assistant thinks about the all the information it has available, and what it should do next (e.g. try the same tool with a different input, try a different tool, or proceed with answering the original user question).
+{{/tools.length}}
+Once enough information is available to provide the Final Answer, the last line in the message needs to be:
+Line starting 'Final Answer: ' followed by a concise and clear answer to the original message.
+
+# Best practices
+- Use markdown syntax for formatting code snippets, links, JSON, tables, images, files.
+{{#tools.length}}
+- Do not attempt to use a tool that is not listed in available tools. This will cause an error.
+- Make sure that tool input is in the correct format and contains the correct arguments.
+{{/tools.length}}
+- When the message is unclear, respond with a line starting with 'Final Answer:' followed by a request for additional information needed to solve the problem.
+- When the user wants to chitchat instead, always respond politely.
+
+# Date and Time
+The current date and time is: {{formatDate}}
+{{#tools.length}}
+You do not need a tool to get the current Date and Time. Use the information available here.
+{{/tools.length}}
+
+{{#instructions}} 
+# Additional instructions
+{{.}} 
+{{/instructions}}
+`;
+});
+const GraniteBeeSchemaErrorPrompt = BeeSchemaErrorPrompt.fork((config) => {
+  config.template = `Error: The generated response does not adhere to the communication structure mentioned in the system prompt.
+You communicate only in instruction lines. Valid instruction lines are 'Thought' followed by 'Tool Name' and then 'Tool Input' or 'Thought' followed by 'Final Answer'.`;
+});
+const GraniteBeeUserPrompt = BeeUserPrompt.fork((config) => {
+  config.template = `{{input}}`;
+});
+const GraniteBeeToolNotFoundPrompt = BeeToolNotFoundPrompt.fork((config) => {
+  config.template = `Tool does not exist!
+{{#tools.length}}
+Use one of the following tools: {{#trim}}{{#tools}}{{name}},{{/tools}}{{/trim}}
+{{/tools.length}}`;
+});
+const GraniteBeeToolErrorPrompt = BeeToolErrorPrompt.fork((config) => {
+  config.template = `The tool has failed; the error log is shown below. If the tool cannot accomplish what you want, use a different tool or explain why you can't use it.
+
+{{reason}}`;
+});
+const GraniteBeeToolInputErrorPrompt = BeeToolInputErrorPrompt.fork((config) => {
+  config.template = `{{reason}}
+
+HINT: If you're convinced that the input was correct but the tool cannot process it then use a different tool or say I don't know.`;
+});
+
+export { GraniteBeeAssistantPrompt, GraniteBeeSchemaErrorPrompt, GraniteBeeSystemPrompt, GraniteBeeToolErrorPrompt, GraniteBeeToolInputErrorPrompt, GraniteBeeToolNotFoundPrompt, GraniteBeeUserPrompt };
+//# sourceMappingURL=prompts.js.map
+//# sourceMappingURL=prompts.js.map

package/dist/agents/bee/runners/granite/prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/agents/bee/runners/granite/prompts.ts"],"names":["GraniteBeeAssistantPrompt","BeeAssistantPrompt","fork","config","template","GraniteBeeSystemPrompt","BeeSystemPrompt","defaults","instructions","functions","formatDate","date","createdAt","Date","Intl","DateTimeFormat","dateStyle","timeStyle","format","GraniteBeeSchemaErrorPrompt","BeeSchemaErrorPrompt","GraniteBeeUserPrompt","BeeUserPrompt","GraniteBeeToolNotFoundPrompt","BeeToolNotFoundPrompt","GraniteBeeToolErrorPrompt","BeeToolErrorPrompt","GraniteBeeToolInputErrorPrompt","BeeToolInputErrorPrompt"],"mappings":";;AA0BO,MAAMA,yBAA4BC,GAAAA,kBAAAA,CAAmBC,IAAK,CAAA,CAACC,MAAAA,KAAAA;AAChEA,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA;;;;AACpB,CAAA;AAEO,MAAMC,sBAAyBC,GAAAA,eAAAA,CAAgBJ,IAAK,CAAA,CAACC,MAAAA,KAAAA;AAC1DA,EAAAA,MAAAA,CAAOI,SAASC,YAAe,GAAA,EAAA;AAC/BL,EAAOM,MAAAA,CAAAA,SAAAA,CAAUC,aAAa,WAAA;AAC5B,IAAMC,MAAAA,IAAAA,GAAO,KAAKC,SAAY,GAAA,IAAIC,KAAK,IAAKD,CAAAA,SAAS,CAAI,mBAAA,IAAIC,IAAAA,EAAAA;AAC7D,IAAO,OAAA,IAAIC,IAAKC,CAAAA,cAAAA,CAAe,OAAS,EAAA;MACtCC,SAAW,EAAA,MAAA;MACXC,SAAW,EAAA;KACb,CAAA,CAAGC,OAAOP,IAAAA,CAAAA;AACZ,GAAA;AACAR,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCpB,CAAA;AAEO,MAAMe,2BAA8BC,GAAAA,oBAAAA,CAAqBlB,IAAK,CAAA,CAACC,MAAAA,KAAAA;AACpEA,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA;;AAEpB,CAAA;AAEO,MAAMiB,oBAAuBC,GAAAA,aAAAA,CAAcpB,IAAK,CAAA,CAACC,MAAAA,KAAAA;AACtDA,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA,SAAA,CAAA;AACpB,CAAA;AAEO,MAAMmB,4BAA+BC,GAAAA,qBAAAA,CAAsBtB,IAAK,CAAA,CAACC,MAAAA,KAAAA;AACtEA,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA;;;;AAIpB,CAAA;AAEO,MAAMqB,yBAA4BC,GAAAA,kBAAAA,CAAmBxB,IAAK,CAAA,CAACC,MAAAA,KAAAA;AAChEA,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA;;;AAGpB,CAAA;AAEO,MAAMuB,8BAAiCC,GAAAA,uBAAAA,CAAwB1B,IAAK,CAAA,CAACC,MAAAA,KAAAA;AAC1EA,EAAAA,MAAAA,CAAOC,QAAW,GAAA,CAAA;;;AAGpB,CAAA","file":"prompts.js","sourcesContent":["/**\n * Copyright 2025 IBM Corp.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  BeeAssistantPrompt,\n  BeeSchemaErrorPrompt,\n  BeeSystemPrompt,\n  BeeToolErrorPrompt,\n  BeeToolInputErrorPrompt,\n  BeeToolNotFoundPrompt,\n  BeeUserPrompt,\n} from \"@/agents/bee/prompts.js\";\n\nexport const GraniteBeeAssistantPrompt = BeeAssistantPrompt.fork((config) => {\n  config.template = `{{#thought}}Thought: {{.}}\\n{{/thought}}{{#toolName}}Tool Name: {{.}}\\n{{/toolName}}{{#toolInput}}Tool Input: {{.}}\\n{{/toolInput}}{{#finalAnswer}}Final Answer: {{.}}{{/finalAnswer}}`;\n});\n\nexport const GraniteBeeSystemPrompt = BeeSystemPrompt.fork((config) => {\n  config.defaults.instructions = \"\";\n  config.functions.formatDate = function () {\n    const date = this.createdAt ? new Date(this.createdAt) : new Date();\n    return new Intl.DateTimeFormat(\"en-US\", {\n      dateStyle: \"full\",\n      timeStyle: \"medium\",\n    }).format(date);\n  };\n  config.template = `You are an AI assistant.\nWhen the user sends a message figure out a solution and provide a final answer.\n{{#tools.length}}\nYou have access to a set of tools that can be used to retrieve information and perform actions.\nPay close attention to the tool description to determine if a tool is useful in a particular context.\n{{/tools.length}}\n\n# Communication structure\nYou communicate only in instruction lines. Valid instruction lines are 'Thought' followed by 'Tool Name' and then 'Tool Input', or 'Thought' followed by 'Final Answer'\n\nLine starting 'Thought: ' The assistant's response always starts with a thought, this is a single line where the assistant thinks about the user's message and describes in detail what it should do next.\n{{#tools.length}}\nIn a 'Thought: ', the assistant should determine if a Tool Call is necessary to get more information or perform an action, or if the available information is sufficient to provide the Final Answer.\nIf a tool needs to be called and is available, the assistant will produce a tool call:\nLine starting 'Tool Name: ' name of the tool that you want to use.\nLine starting 'Tool Input: ' JSON formatted tool arguments adhering to the selected tool parameters schema i.e. {\"arg1\":\"value1\", \"arg2\":\"value2\"}.\nAfter a 'Tool Input: ' the next message will contain a tool response. The next output should be a 'Thought: ' where the assistant thinks about the all the information it has available, and what it should do next (e.g. try the same tool with a different input, try a different tool, or proceed with answering the original user question).\n{{/tools.length}}\nOnce enough information is available to provide the Final Answer, the last line in the message needs to be:\nLine starting 'Final Answer: ' followed by a concise and clear answer to the original message.\n\n# Best practices\n- Use markdown syntax for formatting code snippets, links, JSON, tables, images, files.\n{{#tools.length}}\n- Do not attempt to use a tool that is not listed in available tools. This will cause an error.\n- Make sure that tool input is in the correct format and contains the correct arguments.\n{{/tools.length}}\n- When the message is unclear, respond with a line starting with 'Final Answer:' followed by a request for additional information needed to solve the problem.\n- When the user wants to chitchat instead, always respond politely.\n\n# Date and Time\nThe current date and time is: {{formatDate}}\n{{#tools.length}}\nYou do not need a tool to get the current Date and Time. Use the information available here.\n{{/tools.length}}\n\n{{#instructions}} \n# Additional instructions\n{{.}} \n{{/instructions}}\n`;\n});\n\nexport const GraniteBeeSchemaErrorPrompt = BeeSchemaErrorPrompt.fork((config) => {\n  config.template = `Error: The generated response does not adhere to the communication structure mentioned in the system prompt.\nYou communicate only in instruction lines. Valid instruction lines are 'Thought' followed by 'Tool Name' and then 'Tool Input' or 'Thought' followed by 'Final Answer'.`;\n});\n\nexport const GraniteBeeUserPrompt = BeeUserPrompt.fork((config) => {\n  config.template = `{{input}}`;\n});\n\nexport const GraniteBeeToolNotFoundPrompt = BeeToolNotFoundPrompt.fork((config) => {\n  config.template = `Tool does not exist!\n{{#tools.length}}\nUse one of the following tools: {{#trim}}{{#tools}}{{name}},{{/tools}}{{/trim}}\n{{/tools.length}}`;\n});\n\nexport const GraniteBeeToolErrorPrompt = BeeToolErrorPrompt.fork((config) => {\n  config.template = `The tool has failed; the error log is shown below. If the tool cannot accomplish what you want, use a different tool or explain why you can't use it.\n\n{{reason}}`;\n});\n\nexport const GraniteBeeToolInputErrorPrompt = BeeToolInputErrorPrompt.fork((config) => {\n  config.template = `{{reason}}\n\nHINT: If you're convinced that the input was correct but the tool cannot process it then use a different tool or say I don't know.`;\n});\n"]}

package/dist/agents/bee/runners/granite/runner.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+var message_cjs = require('../../../../backend/message.cjs');
+var runner_cjs = require('../default/runner.cjs');
+var prompts_cjs = require('./prompts.cjs');
+var prompts_cjs$1 = require('../../prompts.cjs');
+var decoratorCache_cjs = require('../../../../cache/decoratorCache.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+class GraniteRunner extends runner_cjs.DefaultRunner {
+  static {
+    __name(this, "GraniteRunner");
+  }
+  useNativeToolCalling = true;
+  get defaultTemplates() {
+    return {
+      system: prompts_cjs.GraniteBeeSystemPrompt,
+      assistant: prompts_cjs.GraniteBeeAssistantPrompt,
+      user: prompts_cjs.GraniteBeeUserPrompt,
+      schemaError: prompts_cjs.GraniteBeeSchemaErrorPrompt,
+      toolNotFoundError: prompts_cjs.GraniteBeeToolNotFoundPrompt,
+      toolError: prompts_cjs.GraniteBeeToolErrorPrompt,
+      toolInputError: prompts_cjs.GraniteBeeToolInputErrorPrompt,
+      // Note: These are from bee
+      userEmpty: prompts_cjs$1.BeeUserEmptyPrompt,
+      toolNoResultError: prompts_cjs$1.BeeToolNoResultsPrompt
+    };
+  }
+  static {
+    this.register();
+  }
+  constructor(input, options, run) {
+    super(input, options, run);
+    run.emitter.on("update", async ({ update, meta, memory, data }) => {
+      if (update.key === "tool_output") {
+        await memory.add(new message_cjs.ToolMessage({
+          type: "tool-result",
+          result: update.value,
+          toolName: data.tool_name,
+          isError: !meta.success,
+          toolCallId: "DUMMY_ID"
+        }, {
+          success: meta.success
+        }));
+      }
+    }, {
+      isBlocking: true
+    });
+  }
+  createParser(tools) {
+    const { parser } = super.createParser(tools);
+    return {
+      parser: parser.fork((nodes, options) => ({
+        options,
+        nodes: {
+          ...nodes,
+          thought: {
+            ...nodes.thought,
+            prefix: "Thought:"
+          },
+          tool_name: {
+            ...nodes.tool_name,
+            prefix: "Tool Name:"
+          },
+          tool_input: {
+            ...nodes.tool_input,
+            prefix: "Tool Input:",
+            isEnd: true,
+            next: []
+          },
+          final_answer: {
+            ...nodes.final_answer,
+            prefix: "Final Answer:"
+          }
+        }
+      }))
+    };
+  }
+}
+_ts_decorate([
+  decoratorCache_cjs.Cache({
+    enumerable: false
+  }),
+  _ts_metadata("design:type", void 0),
+  _ts_metadata("design:paramtypes", [])
+], GraniteRunner.prototype, "defaultTemplates", null);
+
+exports.GraniteRunner = GraniteRunner;
+//# sourceMappingURL=runner.cjs.map
+//# sourceMappingURL=runner.cjs.map

package/dist/agents/bee/runners/granite/runner.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/agents/bee/runners/granite/runner.ts"],"names":["GraniteRunner","DefaultRunner","useNativeToolCalling","defaultTemplates","system","GraniteBeeSystemPrompt","assistant","GraniteBeeAssistantPrompt","user","GraniteBeeUserPrompt","schemaError","GraniteBeeSchemaErrorPrompt","toolNotFoundError","GraniteBeeToolNotFoundPrompt","toolError","GraniteBeeToolErrorPrompt","toolInputError","GraniteBeeToolInputErrorPrompt","userEmpty","BeeUserEmptyPrompt","toolNoResultError","BeeToolNoResultsPrompt","register","constructor","input","options","run","emitter","on","update","meta","memory","data","key","add","ToolMessage","type","result","value","toolName","tool_name","isError","success","toolCallId","isBlocking","createParser","tools","parser","fork","nodes","thought","prefix","tool_input","isEnd","next","final_answer","enumerable"],"mappings":";;;;;;;;;;AAcC,SAAA,YAAA,CAAA,UAAA,EAAA,MAAA,EAAA,GAAA,EAAA,IAAA,EAAA;;;;;;AAAA,MAAA,CAAA,YAAA,EAAA,cAAA,CAAA;;;;;AAoBM,MAAMA,sBAAsBC,wBAAAA,CAAAA;EAlCnC;;;EAmCYC,oBAAuB,GAAA,IAAA;AAEjC,EAAA,IACWC,gBAAmB,GAAA;AAC5B,IAAO,OAAA;MACLC,MAAQC,EAAAA,kCAAAA;MACRC,SAAWC,EAAAA,qCAAAA;MACXC,IAAMC,EAAAA,gCAAAA;MACNC,WAAaC,EAAAA,uCAAAA;MACbC,iBAAmBC,EAAAA,wCAAAA;MACnBC,SAAWC,EAAAA,qCAAAA;MACXC,cAAgBC,EAAAA,0CAAAA;;MAEhBC,SAAWC,EAAAA,gCAAAA;MACXC,iBAAmBC,EAAAA;AACrB,KAAA;AACF;EAEA;AACE,IAAA,IAAA,CAAKC,QAAQ,EAAA;AACf;EAEAC,WAAYC,CAAAA,KAAAA,EAAiBC,SAAwBC,GAA8B,EAAA;AACjF,IAAMF,KAAAA,CAAAA,KAAAA,EAAOC,SAASC,GAAAA,CAAAA;AAEtBA,IAAIC,GAAAA,CAAAA,OAAAA,CAAQC,GACV,QACA,EAAA,OAAO,EAAEC,MAAQC,EAAAA,IAAAA,EAAMC,MAAQC,EAAAA,IAAAA,EAAM,KAAA;AACnC,MAAIH,IAAAA,MAAAA,CAAOI,QAAQ,aAAe,EAAA;AAChC,QAAMF,MAAAA,MAAAA,CAAOG,GACX,CAAA,IAAIC,uBACF,CAAA;UACEC,IAAM,EAAA,aAAA;AACNC,UAAAA,MAAAA,EAAQR,MAAOS,CAAAA,KAAAA;AACfC,UAAAA,QAAAA,EAAUP,IAAKQ,CAAAA,SAAAA;AACfC,UAAAA,OAAAA,EAAS,CAACX,IAAKY,CAAAA,OAAAA;UACfC,UAAY,EAAA;SAEd,EAAA;AAAED,UAAAA,OAAAA,EAASZ,IAAKY,CAAAA;AAAQ,SAAA,CAAA,CAAA;AAG9B;KAEF,EAAA;MACEE,UAAY,EAAA;KACd,CAAA;AAEJ;AAEUC,EAAAA,YAAAA,CAAaC,KAAkB,EAAA;AACvC,IAAA,MAAM,EAAEC,MAAAA,EAAW,GAAA,KAAA,CAAMF,aAAaC,KAAAA,CAAAA;AAEtC,IAAO,OAAA;AACLC,MAAAA,MAAAA,EAAQA,MAAOC,CAAAA,IAAAA,CAAqB,CAACC,KAAAA,EAAOxB,OAAa,MAAA;AACvDA,QAAAA,OAAAA;QACAwB,KAAO,EAAA;UACL,GAAGA,KAAAA;UACHC,OAAS,EAAA;AAAE,YAAA,GAAGD,KAAMC,CAAAA,OAAAA;YAASC,MAAQ,EAAA;AAAW,WAAA;UAChDX,SAAW,EAAA;AAAE,YAAA,GAAGS,KAAMT,CAAAA,SAAAA;YAAWW,MAAQ,EAAA;AAAa,WAAA;UACtDC,UAAY,EAAA;AAAE,YAAA,GAAGH,KAAMG,CAAAA,UAAAA;YAAYD,MAAQ,EAAA,aAAA;YAAeE,KAAO,EAAA,IAAA;AAAMC,YAAAA,IAAAA,EAAM;AAAG,WAAA;UAChFC,YAAc,EAAA;AAAE,YAAA,GAAGN,KAAMM,CAAAA,YAAAA;YAAcJ,MAAQ,EAAA;AAAgB;AACjE;OACF,CAAA;AACF,KAAA;AACF;AACF;;;IA/DWK,UAAY,EAAA","file":"runner.cjs","sourcesContent":["/**\n * Copyright 2025 IBM Corp.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ToolMessage } from \"@/backend/message.js\";\nimport type { AnyTool } from \"@/tools/base.js\";\nimport { DefaultRunner } from \"@/agents/bee/runners/default/runner.js\";\nimport type { BeeParserInput, BeeRunOptions } from \"@/agents/bee/types.js\";\nimport { BeeAgent, BeeInput } from \"@/agents/bee/agent.js\";\nimport type { GetRunContext } from \"@/context.js\";\nimport {\n  GraniteBeeAssistantPrompt,\n  GraniteBeeSchemaErrorPrompt,\n  GraniteBeeSystemPrompt,\n  GraniteBeeToolErrorPrompt,\n  GraniteBeeToolInputErrorPrompt,\n  GraniteBeeToolNotFoundPrompt,\n  GraniteBeeUserPrompt,\n} from \"@/agents/bee/runners/granite/prompts.js\";\nimport { BeeToolNoResultsPrompt, BeeUserEmptyPrompt } from \"@/agents/bee/prompts.js\";\nimport { Cache } from \"@/cache/decoratorCache.js\";\n\nexport class GraniteRunner extends DefaultRunner {\n  protected useNativeToolCalling = true;\n\n  @Cache({ enumerable: false })\n  public get defaultTemplates() {\n    return {\n      system: GraniteBeeSystemPrompt,\n      assistant: GraniteBeeAssistantPrompt,\n      user: GraniteBeeUserPrompt,\n      schemaError: GraniteBeeSchemaErrorPrompt,\n      toolNotFoundError: GraniteBeeToolNotFoundPrompt,\n      toolError: GraniteBeeToolErrorPrompt,\n      toolInputError: GraniteBeeToolInputErrorPrompt,\n      // Note: These are from bee\n      userEmpty: BeeUserEmptyPrompt,\n      toolNoResultError: BeeToolNoResultsPrompt,\n    };\n  }\n\n  static {\n    this.register();\n  }\n\n  constructor(input: BeeInput, options: BeeRunOptions, run: GetRunContext<BeeAgent>) {\n    super(input, options, run);\n\n    run.emitter.on(\n      \"update\",\n      async ({ update, meta, memory, data }) => {\n        if (update.key === \"tool_output\") {\n          await memory.add(\n            new ToolMessage(\n              {\n                type: \"tool-result\",\n                result: update.value!,\n                toolName: data.tool_name!,\n                isError: !meta.success,\n                toolCallId: \"DUMMY_ID\",\n              },\n              { success: meta.success },\n            ),\n          );\n        }\n      },\n      {\n        isBlocking: true,\n      },\n    );\n  }\n\n  protected createParser(tools: AnyTool[]) {\n    const { parser } = super.createParser(tools);\n\n    return {\n      parser: parser.fork<BeeParserInput>((nodes, options) => ({\n        options,\n        nodes: {\n          ...nodes,\n          thought: { ...nodes.thought, prefix: \"Thought:\" },\n          tool_name: { ...nodes.tool_name, prefix: \"Tool Name:\" },\n          tool_input: { ...nodes.tool_input, prefix: \"Tool Input:\", isEnd: true, next: [] },\n          final_answer: { ...nodes.final_answer, prefix: \"Final Answer:\" },\n        },\n      })),\n    };\n  }\n}\n"]}

package/dist/agents/bee/runners/granite/runner.d.cts

@@ -0,0 +1,167 @@
+import { LinePrefixParser } from '../../../../parsers/linePrefix.cjs';
+import { PromptTemplate } from '../../../../template.cjs';
+import * as zod from 'zod';
+import { AnyTool } from '../../../../tools/base.cjs';
+import { DefaultRunner } from '../default/runner.cjs';
+import { BeeRunOptions, BeeParserInput } from '../../types.cjs';
+import { B as BeeInput, a as BeeAgent } from '../../../../agent-BbaHVlob.cjs';
+import { GetRunContext } from '../../../../context.cjs';
+import '../../../../emitter-BWtGHYn0.cjs';
+import '../../../../internals/types.cjs';
+import '../../../../internals/helpers/guards.cjs';
+import '../../../../internals/serializable.cjs';
+import '../../../../parsers/field.cjs';
+import '@streamparser/json';
+import 'jsonrepair/stream';
+import '../../../../parsers/errors.cjs';
+import '../../../../errors.cjs';
+import 'ajv';
+import 'promise-based-task';
+import '../../../../cache/base.cjs';
+import '../../../../internals/helpers/schema.cjs';
+import 'zod-to-json-schema';
+import '../../../../internals/helpers/promise.cjs';
+import '../../../../backend/message.cjs';
+import 'ai';
+import '../../../../memory/base.cjs';
+import '../../../../base-Csr9guq2.cjs';
+import '../../../../backend/chat.cjs';
+import '../../../../backend/utils.cjs';
+import '../../../../backend/constants.cjs';
+import '@ai-sdk/provider';
+import '../../../../internals/helpers/counter.cjs';
+import '../../prompts.cjs';
+
+declare class GraniteRunner extends DefaultRunner {
+    protected useNativeToolCalling: boolean;
+    get defaultTemplates(): {
+        system: PromptTemplate<zod.ZodObject<{
+            instructions: zod.ZodDefault<zod.ZodString>;
+            tools: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+                description: zod.ZodString;
+                schema: zod.ZodString;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                name: zod.ZodString;
+                description: zod.ZodString;
+                schema: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                name: zod.ZodString;
+                description: zod.ZodString;
+                schema: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">>, "many">;
+            createdAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        }, "strip", zod.ZodTypeAny, {
+            instructions: string;
+            tools: zod.objectOutputType<{
+                name: zod.ZodString;
+                description: zod.ZodString;
+                schema: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">[];
+            createdAt?: string | null | undefined;
+        }, {
+            tools: zod.objectInputType<{
+                name: zod.ZodString;
+                description: zod.ZodString;
+                schema: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">[];
+            createdAt?: string | null | undefined;
+            instructions?: string | undefined;
+        }>>;
+        assistant: PromptTemplate<zod.ZodObject<{
+            thought: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            toolName: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            toolInput: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            toolOutput: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            finalAnswer: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+        }, "strip", zod.ZodTypeAny, {
+            toolName?: string[] | undefined;
+            thought?: string[] | undefined;
+            toolInput?: string[] | undefined;
+            toolOutput?: string[] | undefined;
+            finalAnswer?: string[] | undefined;
+        }, {
+            toolName?: string[] | undefined;
+            thought?: string[] | undefined;
+            toolInput?: string[] | undefined;
+            toolOutput?: string[] | undefined;
+            finalAnswer?: string[] | undefined;
+        }>>;
+        user: PromptTemplate<zod.ZodObject<{
+            input: zod.ZodString;
+            meta: zod.ZodOptional<zod.ZodObject<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, zod.ZodTypeAny, "passthrough">>>;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            input: zod.ZodString;
+            meta: zod.ZodOptional<zod.ZodObject<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, zod.ZodTypeAny, "passthrough">>>;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            input: zod.ZodString;
+            meta: zod.ZodOptional<zod.ZodObject<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                createdAt: zod.ZodOptional<zod.ZodString>;
+            }, zod.ZodTypeAny, "passthrough">>>;
+        }, zod.ZodTypeAny, "passthrough">>>;
+        schemaError: PromptTemplate<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+        toolNotFoundError: PromptTemplate<zod.ZodObject<{
+            tools: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                name: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                name: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">>, "many">;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            tools: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                name: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                name: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">>, "many">;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            tools: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                name: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                name: zod.ZodString;
+            }, zod.ZodTypeAny, "passthrough">>, "many">;
+        }, zod.ZodTypeAny, "passthrough">>>;
+        toolError: PromptTemplate<zod.ZodObject<{
+            reason: zod.ZodString;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            reason: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            reason: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">>>;
+        toolInputError: PromptTemplate<zod.ZodObject<{
+            reason: zod.ZodString;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            reason: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            reason: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">>>;
+        userEmpty: PromptTemplate<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+        toolNoResultError: PromptTemplate<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+    };
+    constructor(input: BeeInput, options: BeeRunOptions, run: GetRunContext<BeeAgent>);
+    protected createParser(tools: AnyTool[]): {
+        parser: LinePrefixParser<BeeParserInput>;
+    };
+}
+
+export { GraniteRunner };