kernl 0.1.1

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> kernl@0.1.0 build /Users/andjones/Documents/projects/kernl/packages/kernl
+> tsc && tsc-alias
+

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# @kernl/core
+
+## 0.1.1
+
+### Patch Changes
+
+- Initial release of Kernl AI agent framework with modular architecture
+- Updated dependencies
+  - @kernl/protocol@0.1.1
+  - @kernl/shared@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- cd1653b: Initial implementation of Kernl agent framework (v0.1.0)
+
+  This release implements the core architecture for building agentic applications with a Linux kernel-inspired design:
+
+  **Core Agent Framework:**
+  - Agent class with instructions, model configuration, tools, and guardrails
+  - Thread execution loop with tick-based model interaction
+  - Context management for passing data between components
+  - Lifecycle hooks for extensibility
+
+  **Thread Execution:**
+  - Multi-turn conversation handling with tool calls
+  - Parallel tool execution support
+  - Terminal state detection
+  - State tracking (tick counter, model responses, history)
+
+  **Tool System:**
+  - Function tool definition with Zod schema validation
+  - Toolkit for managing collections of tools
+  - MCP (Model Context Protocol) server integration (stdio, HTTP, SSE transports)
+  - Tool approval workflow support
+  - Error handling with custom error functions
+
+  **Infrastructure:**
+  - Language model interface and provider registry
+  - Serialization system (codec, JSON, thread, tool)
+  - Tracing and observability hooks
+  - Usage tracking
+  - Input/output guardrails
+
+  **Testing:**
+  - Comprehensive test suite for Thread class (13 tests)
+  - Tool and toolkit test coverage
+  - Mock language model for testing
+
+  This is the foundational "Hello World" implementation - a working agent that can execute tool calls and maintain conversation history.
+
+- 6bcc501: Add comprehensive MCP testing and multi-toolkit support. Introduces 64 tests for MCP implementation and refactors agent architecture to support multiple toolkits with duplicate detection. Includes tool() and tools() methods for cross-toolkit lookups.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

package/dist/agent.d.ts

@@ -0,0 +1,43 @@
+import { LanguageModel, LanguageModelRequestSettings } from "@kernl/protocol";
+import type { Context, UnknownContext } from "./context";
+import { InputGuardrail, OutputGuardrail } from "./guardrail";
+import { AgentHooks } from "./lifecycle";
+import { Toolkit } from "./tool/toolkit";
+import { Tool } from "./tool";
+import type { AgentConfig, AgentResponseType } from "./types/agent";
+import { TextResponse } from "./types/thread";
+export declare class Agent<TContext = UnknownContext, TResponse extends AgentResponseType = TextResponse> extends AgentHooks<TContext, TResponse> implements AgentConfig<TContext, TResponse> {
+    id: string;
+    name: string;
+    instructions: (context: Context<TContext>) => Promise<string> | string;
+    model: LanguageModel;
+    modelSettings: LanguageModelRequestSettings;
+    toolkits: Toolkit<TContext>[];
+    guardrails: {
+        input: InputGuardrail[];
+        output: OutputGuardrail<AgentResponseType>[];
+    };
+    responseType: TResponse;
+    resetToolChoice: boolean;
+    constructor(config: AgentConfig<TContext, TResponse>);
+    /**
+     * Get a specific tool by ID from all toolkits.
+     *
+     * @param id The tool ID to look up
+     * @returns The tool if found, undefined otherwise
+     */
+    tool(id: string): Tool<TContext> | undefined;
+    /**
+     * Get all tools available from all toolkits for the given context.
+     * Checks for duplicate tool IDs across toolkits and throws an error if found.
+     *
+     * (TODO): Consider returning toolkits alongside tools so we can serialize them
+     * together and give agents more options for dealing with tool groups.
+     *
+     * @param context The context to use for filtering tools
+     * @returns Array of all available tools
+     * @throws {MisconfiguredError} If duplicate tool IDs are found across toolkits
+     */
+    tools(context: Context<TContext>): Promise<Tool<TContext>[]>;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAE9E,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAK9B,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,qBAAa,KAAK,CACd,QAAQ,GAAG,cAAc,EACzB,SAAS,SAAS,iBAAiB,GAAG,YAAY,CAEpD,SAAQ,UAAU,CAAC,QAAQ,EAAE,SAAS,CACtC,YAAW,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC;IAE3C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IAEvE,KAAK,EAAE,aAAa,CAAC;IACrB,aAAa,EAAE,4BAA4B,CAAC;IAC5C,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;IAa9B,UAAU,EAAE;QACV,KAAK,EAAE,cAAc,EAAE,CAAC;QACxB,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAAE,CAAC;KAC9C,CAAC;IACF,YAAY,EAAE,SAAS,CAAuB;IAC9C,eAAe,EAAE,OAAO,CAAC;gBAsBb,MAAM,EAAE,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC;IAsDpD;;;;;OAKG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,SAAS;IAQ5C;;;;;;;;;;OAUG;IACG,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;CAwDnE"}

package/dist/agent.js

@@ -0,0 +1,130 @@
+import { AgentHooks } from "./lifecycle";
+// import { DEFAULT_LANGUAGE_MODEL } from "./providers/default";
+import { MisconfiguredError } from "./lib/error";
+export class Agent extends AgentHooks {
+    id;
+    name;
+    instructions;
+    model;
+    modelSettings;
+    toolkits;
+    // --- (TODO) ---
+    // handoffDescription: string; // ??
+    // handoffs: (Agent<any, TResponse> | Handoff<any, TResponse>)[];
+    // ----------
+    // /* Process/thread-group–wide signal state shared by all threads in the group: shared pending signals, job control
+    // (stops/cont, group exit), rlimits, etc. */
+    // signal: *struct signal_struct;
+    //  /* Table of signal handlers (sa_handler, sa_mask, flags) shared by threads (CLONE_SIGHAND). RCU-protected so readers can access it locklessly. */
+    // sighand: *struct sighand_struct __rcu;
+    guardrails;
+    responseType = "text";
+    resetToolChoice;
+    // toolUseBehavior: ToolUseBehavior; (TODO)
+    // /**
+    //  * Create an Agent with handoffs and automatically infer the union type for TResponse from the handoff agents' response types.
+    //  */
+    // static create<
+    //   TResponse extends AgentResponseType = TextResponse,
+    //   Handoffs extends readonly (Agent<any, any> | Handoff<any, any>)[] = [],
+    // >(
+    //   config: AgentConfigWithHandoffs<TResponse, Handoffs>,
+    // ): Agent<UnknownContext, TResponse | HandoffsOutputUnion<Handoffs>> {
+    //   return new Agent<UnknownContext, TResponse | HandoffsOutputUnion<Handoffs>>(
+    //     {
+    //       ...config,
+    //       handoffs: config.handoffs as any,
+    //       responseType: config.responseType,
+    //       handoffresponseTypeWarningEnabled: false,
+    //     },
+    //   );
+    // }
+    constructor(config) {
+        super();
+        if (config.id.trim() === "") {
+            throw new MisconfiguredError("Agent must have an id.");
+        }
+        this.id = config.id;
+        this.name = config.name;
+        this.instructions =
+            typeof config.instructions === "function"
+                ? config.instructions
+                : () => config.instructions;
+        this.model = config.model; // TODO: Add default model
+        this.modelSettings = config.modelSettings ?? {};
+        this.toolkits = config.toolkits ?? [];
+        for (const toolkit of this.toolkits) {
+            toolkit.bind(this);
+        }
+        this.guardrails = config.guardrails ?? { input: [], output: [] };
+        if (config.responseType) {
+            this.responseType = config.responseType;
+        }
+        this.resetToolChoice = config.resetToolChoice ?? true;
+        // this.toolUseBehavior = config.toolUseBehavior ?? "run_llm_again";
+        // this.handoffDescription = config.handoffDescription ?? "";
+        // this.handoffs = config.handoffs ?? [];
+        // --- Runtime warning for handoff response type compatibility ---
+        // if (
+        //   config.handoffresponseTypeWarningEnabled === undefined ||
+        //   config.handoffresponseTypeWarningEnabled
+        // ) {
+        //   if (this.handoffs && this.responseType) {
+        //     const responseTypes = new Set<string>([
+        //       JSON.stringify(this.responseType),
+        //     ]);
+        //     for (const h of this.handoffs) {
+        //       if ("responseType" in h && h.responseType) {
+        //         responseTypes.add(JSON.stringify(h.responseType));
+        //       } else if ("agent" in h && h.agent.responseType) {
+        //         responseTypes.add(JSON.stringify(h.agent.responseType));
+        //       }
+        //     }
+        //     if (responseTypes.size > 1) {
+        //       logger.warn(
+        //         `[Agent] Warning: Handoff agents have different response types: ${Array.from(responseTypes).join(", ")}. You can make it type-safe by using Agent.create({ ... }) method instead.`,
+        //       );
+        //     }
+        //   }
+        // }
+    }
+    /**
+     * Get a specific tool by ID from all toolkits.
+     *
+     * @param id The tool ID to look up
+     * @returns The tool if found, undefined otherwise
+     */
+    tool(id) {
+        for (const toolkit of this.toolkits) {
+            const tool = toolkit.get(id);
+            if (tool)
+                return tool;
+        }
+        return undefined;
+    }
+    /**
+     * Get all tools available from all toolkits for the given context.
+     * Checks for duplicate tool IDs across toolkits and throws an error if found.
+     *
+     * (TODO): Consider returning toolkits alongside tools so we can serialize them
+     * together and give agents more options for dealing with tool groups.
+     *
+     * @param context The context to use for filtering tools
+     * @returns Array of all available tools
+     * @throws {MisconfiguredError} If duplicate tool IDs are found across toolkits
+     */
+    async tools(context) {
+        const allTools = [];
+        const toolIds = new Set();
+        for (const toolkit of this.toolkits) {
+            const tools = await toolkit.list(context);
+            const duplicates = tools.map((t) => t.id).filter((id) => toolIds.has(id));
+            if (duplicates.length > 0) {
+                throw new MisconfiguredError(`Duplicate tool IDs found across toolkits: ${duplicates.join(", ")}`);
+            }
+            tools.forEach((t) => toolIds.add(t.id));
+            allTools.push(...tools);
+        }
+        return allTools;
+    }
+}

package/dist/context.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Status of a tool call approval.
+ */
+export type ApprovalStatus = "approved" | "rejected" | "pending";
+/**
+ * A propagation mechanism which carries execution-scoped values across API boundaries and between logically associated
+ * execution units.
+ */
+export declare class Context<TContext = UnknownContext> {
+    /**
+     * The inner context object.
+     */
+    context: TContext;
+    /**
+     * Map of tool call IDs to their approval status.
+     * (TEMPORARY) Used until the actions system is refined.
+     */
+    approvals: Map<string, ApprovalStatus>;
+    /**
+     * Approve a tool call by its call ID.
+     * (TEMPORARY) Used until the actions system is refined.
+     */
+    approve(callId: string): void;
+    /**
+     * Reject a tool call by its call ID.
+     * (TEMPORARY) Used until the actions system is refined.
+     */
+    reject(callId: string): void;
+    constructor(context?: TContext);
+    /**
+     * Renders the context as a prompt using the default format selected. Kernel would inject this info automatically, but exposed in case of control
+     */
+    render(self: Context<TContext>): string;
+    /**
+     * Render the context object as a markdown string:
+     *
+     *  <context>
+     *    <user>
+     *      <name>John</name>
+     *      <email>john@gmail.com</email>
+     *    </user>
+     *    <org>
+     *      <id>org_235234523</id>
+     *      <name>Acme Corp.<name>
+     *    </org>
+     *  </context>
+     *
+     */
+    md(): string;
+    /**
+     *  Render the context object as a yaml string:
+     *
+     *  context:
+     *    user:
+     *      name: John
+     *      email: john@gmail.com
+     *    org:
+     *      id: org_235234523
+     *      name: Acme Corp.
+     */
+    yaml(): string;
+    toJSON(): {
+        context: any;
+    };
+}
+/**
+ * Context that is being passed around as part of the session is unknown
+ */
+export type UnknownContext = unknown;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;AAEjE;;;GAGG;AACH,qBAAa,OAAO,CAAC,QAAQ,GAAG,cAAc;IAC5C;;OAEG;IACH,OAAO,EAAE,QAAQ,CAAC;IAMlB;;;OAGG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAEvC;;;OAGG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI7B;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;gBAwBhB,OAAO,GAAE,QAAyB;IAQ9C;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM;IAevC;;;;;;;;;;;;;;OAcG;IACH,EAAE,IAAI,MAAM;IAIZ;;;;;;;;;;OAUG;IACH,IAAI,IAAI,MAAM;IAId,MAAM,IAAI;QACR,OAAO,EAAE,GAAG,CAAC;KAGd;CAsIF;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC"}

package/dist/context.js

@@ -0,0 +1,111 @@
+/**
+ * A propagation mechanism which carries execution-scoped values across API boundaries and between logically associated
+ * execution units.
+ */
+export class Context {
+    /**
+     * The inner context object.
+     */
+    context;
+    // ----------------------
+    // TEMPORARY: Tool approval tracking until actions system is refined
+    // ----------------------
+    /**
+     * Map of tool call IDs to their approval status.
+     * (TEMPORARY) Used until the actions system is refined.
+     */
+    approvals;
+    /**
+     * Approve a tool call by its call ID.
+     * (TEMPORARY) Used until the actions system is refined.
+     */
+    approve(callId) {
+        this.approvals.set(callId, "approved");
+    }
+    /**
+     * Reject a tool call by its call ID.
+     * (TEMPORARY) Used until the actions system is refined.
+     */
+    reject(callId) {
+        this.approvals.set(callId, "rejected");
+    }
+    // ----------------------
+    // End temporary approval tracking
+    // ----------------------
+    // /**
+    //  * Serialization format in which to render the context to the agent
+    //  */
+    // private format: "md" | "yaml" | "json" | "html" | "xml";
+    // /**
+    //  * The usage of the agent run so far. For streamed responses, the usage will be stale until the
+    //  * last chunk of the stream is processed.
+    //  */
+    // usage: Usage;
+    // /**
+    //  * A map of tool names to whether they have been approved.
+    //  */
+    // #approvals: Map<string, ApprovalRecord>;
+    constructor(context = {}) {
+        this.context = context;
+        this.approvals = new Map();
+        // this.format = format; // (TODO): configure()
+        // this.usage = new Usage();
+        // this.#approvals = new Map();
+    }
+    /**
+     * Renders the context as a prompt using the default format selected. Kernel would inject this info automatically, but exposed in case of control
+     */
+    render(self) {
+        throw new Error("UNIMPLEMENTED");
+        // switch (self.format) {
+        //   case "yaml":
+        //     return self.yaml();
+        //   // case "json":
+        //   //   return self.json();
+        //   // case "xml":
+        //   //   return self.xml();
+        //   case "md":
+        //   default:
+        //     return self.md();
+        // }
+    }
+    /**
+     * Render the context object as a markdown string:
+     *
+     *  <context>
+     *    <user>
+     *      <name>John</name>
+     *      <email>john@gmail.com</email>
+     *    </user>
+     *    <org>
+     *      <id>org_235234523</id>
+     *      <name>Acme Corp.<name>
+     *    </org>
+     *  </context>
+     *
+     */
+    md() {
+        throw new Error("UNIMPLEMENTED");
+    }
+    /**
+     *  Render the context object as a yaml string:
+     *
+     *  context:
+     *    user:
+     *      name: John
+     *      email: john@gmail.com
+     *    org:
+     *      id: org_235234523
+     *      name: Acme Corp.
+     */
+    yaml() {
+        throw new Error("UNIMPLEMENTED");
+    }
+    toJSON() {
+        return {
+            context: this.context,
+            // usage: this.usage,
+            // approvals: Object.fromEntries(this.#approvals.entries()),
+        };
+    }
+}

package/dist/env.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+/**
+ * Environment variable validation schema
+ *
+ * This ensures all environment variables are valid at startup.
+ * All variables are optional with sensible defaults.
+ */
+declare const envSchema: z.ZodObject<{
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        trace: "trace";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+        error: "error";
+        fatal: "fatal";
+    }>>;
+    KERNL_LOG_MODEL_DATA: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false" | undefined>>;
+    KERNL_LOG_TOOL_DATA: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false" | undefined>>;
+}, z.core.$strip>;
+/**
+ * Validated and type-safe environment variables
+ *
+ * Use this throughout the library instead of process.env directly.
+ *
+ * @example
+ * import { env } from './env';
+ * console.log(env.LOG_LEVEL);
+ */
+export declare const env: {
+    LOG_LEVEL: "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+    KERNL_LOG_MODEL_DATA: boolean;
+    KERNL_LOG_TOOL_DATA: boolean;
+};
+/**
+ * Type of the validated environment variables
+ */
+export type Env = z.infer<typeof envSchema>;
+export {};
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AACH,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;iBAab,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG;;;;CAA+B,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}