nemo-fabric-adapters-droid 0.0.0 → 0.5.0

package/LICENSE

@@ -1,194 +1,8 @@
-Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-
                                  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]
+   Copyright 2026 NVIDIA CORPORATION & AFFILIATES
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -1,3 +1,111 @@
-# NVIDIA NeMo Fabric Droid Adapter
+<!--
+SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+-->
 
-Version 0.0.0 is an inert registry bootstrap used to configure npm trusted publishing. It contains no adapter implementation. Supported versions are published by NVIDIA NeMo Fabric release workflows.
+# NVIDIA NeMo Fabric Factory Droid Adapter
+
+This package provides the bundled `nvidia.fabric.droid` process adapter. It
+uses Factory's supported TypeScript SDK and retains one Droid session for the
+lifetime of each NeMo Fabric runtime.
+
+Install the supported SDK and caller-owned Droid CLI separately, then install
+the adapter in the same Node.js project:
+
+```bash
+npm install --global droid@0.233.0
+npm install --save-exact @factory/droid-sdk@0.9.1
+npm install nemo-fabric-adapters-droid
+```
+
+The adapter never installs the Droid CLI at runtime. A missing SDK returns
+`droid_harness_unavailable`; a missing CLI returns `droid_cli_unavailable`.
+Set the Factory API key referenced by the Fabric model configuration before
+starting a runtime.
+
+For source development, install and build the focused workspace from the
+repository root:
+
+```bash
+just install-typescript-droid
+npm run build --prefix adapter-contract/typescript
+npm run build --prefix adapters/typescript --workspace nemo-fabric-adapters-common
+npm run build --prefix adapters/typescript --workspace nemo-fabric-adapters-droid
+```
+
+Point `DiscoveryConfig.local_paths` at the installed descriptor:
+
+```python
+from nemo_fabric import DiscoveryConfig, FabricConfig, HarnessConfig
+from nemo_fabric import InstructionConfig, InstructionsConfig
+from nemo_fabric import MetadataConfig, ModelConfig, ToolsConfig
+
+config = FabricConfig(
+    metadata=MetadataConfig(name="droid-agent"),
+    discovery=DiscoveryConfig(
+        local_paths=[
+            "./node_modules/nemo-fabric-adapters-droid/droid.fabric-adapter.json"
+        ]
+    ),
+    harness=HarnessConfig(adapter_id="nvidia.fabric.droid"),
+    models={
+        "default": ModelConfig(
+            provider="factory",
+            model="auto",
+            api_key_env="FACTORY_API_KEY",
+        )
+    },
+    instructions=InstructionsConfig(
+        system=InstructionConfig(
+            content="Review code for correctness risks.",
+            mode="append",
+        )
+    ),
+    tools=ToolsConfig(enabled=["Read", "Grep", "Glob"]),
+)
+config.add_skill_path("./skills/code-review")
+```
+
+For a source build, use
+`adapters/typescript/droid/droid.fabric-adapter.json`.
+
+The initial adapter supports model IDs resolved by Droid, a Factory API-key
+environment reference, replacement or appended system instructions, exact
+Droid built-in tool enable/block policy, normalized skill paths, and
+unauthenticated stdio, SSE, and streamable HTTP MCP servers. Tool values are
+Droid tool IDs; inspect the IDs
+available to a model with `droid exec --model MODEL_ID --list-tools
+--output-format json`.
+
+Each NeMo Fabric runtime owns one SDK session. Ordered invocations call
+`session.stream()` on that retained session, so the caller does not replay
+history. `stop()` closes the session and its CLI subprocess. Independent
+runtimes create separate sessions.
+
+Configured skill directories are copied into a runtime-scoped temporary home
+using Droid's compatible personal `.agents/skills` layout. The adapter verifies
+them with `listSkills()` and removes the temporary home during shutdown. This
+keeps Fabric-provided skills isolated without modifying the workspace.
+The isolated profile preserves Factory `settings.json` and
+`settings.local.json` for custom model definitions but does not copy ambient
+MCP configuration or authentication state.
+
+## Optional: Configure a Custom BYOK Model
+
+The default configuration above uses Droid's `auto` model selection and a
+Factory API key. Use the following optional configuration only when Droid must
+call a custom model endpoint through BYOK. The integration guide uses an
+NVIDIA-hosted model as one example.
+
+To use a custom BYOK model, define the unprefixed model ID in either Factory
+settings file and set `apiKey` to an exact reference to the provider's existing
+credential variable, such as `${NVIDIA_API_KEY}`. The adapter forwards only the
+variable referenced by the selected custom model. Refer to the
+[Droid integration guide](../../../docs/integrations/harness/droid.mdx#optional-use-a-custom-byok-model)
+for the complete optional setup.
+
+The adapter intentionally does not accept normalized custom model endpoints.
+Droid custom endpoints are configured outside a session in Droid settings. It
+also does not advertise streaming, telemetry, or Relay integration. Unsupported
+normalized fields, MCP authentication and per-server tool filters, unknown
+settings, and unknown built-in tool IDs fail instead of being ignored.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { serve } from "nemo-fabric-adapters-common";
+await serve(async () => {
+    const [{ DroidSdkSessionFactory }, { DroidAdapterRuntime }] = await Promise.all([
+        import("./droid-sdk.js"),
+        import("./runtime.js"),
+    ]);
+    return new DroidAdapterRuntime(new DroidSdkSessionFactory());
+});

package/dist/droid-sdk.d.ts

@@ -0,0 +1,39 @@
+import { type AdapterStartInput } from "nemo-fabric-adapters-common";
+import type { DroidSessionFactory, DroidSessionHandle } from "./runtime.js";
+interface DroidToolInfo {
+    id?: unknown;
+}
+interface DroidMcpToolInfo {
+    serverName?: unknown;
+    name?: unknown;
+}
+interface DroidSkillInfo {
+    name?: unknown;
+    filePath?: unknown;
+    enabled?: unknown;
+}
+interface DroidSdkSession {
+    readonly id: string;
+    stream(prompt: string): AsyncGenerator<unknown, void, undefined>;
+    close(): Promise<void>;
+    listTools(): Promise<DroidToolInfo[]>;
+    updateSettings(settings: {
+        disabledToolIds: string[];
+    }): Promise<unknown>;
+    listMcpTools(): Promise<DroidMcpToolInfo[]>;
+    listSkills(): Promise<{
+        skills: DroidSkillInfo[];
+    }>;
+}
+interface DroidSdkModule {
+    createSession(options: Record<string, unknown>): Promise<DroidSdkSession>;
+}
+export type DroidSdkLoader = () => Promise<DroidSdkModule>;
+export declare class DroidSdkSessionFactory implements DroidSessionFactory {
+    private readonly loader;
+    private readonly mcpStartupTimeoutMs;
+    private readonly parentEnvironment;
+    constructor(loader?: DroidSdkLoader, mcpStartupTimeoutMs?: number, parentEnvironment?: NodeJS.ProcessEnv);
+    create(input: AdapterStartInput): Promise<DroidSessionHandle>;
+}
+export {};

package/dist/droid-sdk.js

@@ -0,0 +1,636 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { cp, mkdir, mkdtemp, readFile, realpath, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { LifecycleError } from "nemo-fabric-adapters-common";
+const DROID_SDK_INSTALL_COMMAND = "npm install @factory/droid-sdk@0.9.1";
+const MCP_STARTUP_TIMEOUT_MS = 10_000;
+const MCP_STATUS_POLL_INTERVAL_MS = 50;
+const INHERITED_ENVIRONMENT_NAMES = new Set([
+    "APPDATA",
+    "BUN_INSTALL",
+    "COMSPEC",
+    "ComSpec",
+    "DBUS_SESSION_BUS_ADDRESS",
+    "HOME",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LOCALAPPDATA",
+    "NO_PROXY",
+    "PATH",
+    "PATHEXT",
+    "Path",
+    "PathExt",
+    "SHELL",
+    "SSL_CERT_DIR",
+    "SSL_CERT_FILE",
+    "SYSTEMROOT",
+    "SystemRoot",
+    "TEMP",
+    "TERM",
+    "TERM_PROGRAM",
+    "TMP",
+    "TMPDIR",
+    "USER",
+    "USERPROFILE",
+    "XDG_CACHE_HOME",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_RUNTIME_DIR",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+]);
+function isMissingModuleError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND"));
+}
+async function loadDroidSdk() {
+    try {
+        const moduleName = "@factory/droid-sdk/node";
+        const sdk = (await import(moduleName));
+        if (typeof sdk.createSession !== "function") {
+            throw new LifecycleError("droid_harness_incompatible", "The installed Factory Droid SDK does not expose createSession");
+        }
+        return sdk;
+    }
+    catch (error) {
+        if (error instanceof LifecycleError)
+            throw error;
+        if (isMissingModuleError(error)) {
+            throw new LifecycleError("droid_harness_unavailable", `The Factory Droid SDK is not installed. Install the supported SDK with: ${DROID_SDK_INSTALL_COMMAND}`);
+        }
+        throw new LifecycleError("droid_harness_load_failed", "The installed Factory Droid SDK could not be loaded");
+    }
+}
+function selectModel(config) {
+    const entries = Object.entries(config.models ?? {});
+    if (entries.length === 0) {
+        throw new LifecycleError("droid_model_required", "The Droid adapter requires one configured model");
+    }
+    const selected = config.models?.default ?? (entries.length === 1 ? entries[0]?.[1] : undefined);
+    if (selected === undefined) {
+        throw new LifecycleError("droid_model_ambiguous", "Configure a default model role when the Droid adapter receives multiple models");
+    }
+    if (selected.provider !== "factory") {
+        throw new LifecycleError("droid_provider_unsupported", "The Droid adapter requires models to use provider='factory'");
+    }
+    return selected;
+}
+function credentialValue(input, name, parentEnvironment) {
+    return input.runtimeContext.environment.env?.[name] ?? parentEnvironment[name];
+}
+function replaceEnvironment(values) {
+    for (const name of Object.keys(process.env)) {
+        delete process.env[name];
+    }
+    for (const [name, value] of Object.entries(values)) {
+        if (value !== undefined)
+            process.env[name] = value;
+    }
+}
+function leaseEnvironment(configured, credentialName, credential, parentEnvironment) {
+    const original = { ...process.env };
+    const values = Object.create(null);
+    for (const name of INHERITED_ENVIRONMENT_NAMES) {
+        const value = parentEnvironment[name];
+        if (value !== undefined)
+            values[name] = value;
+    }
+    Object.assign(values, configured);
+    values[credentialName] = credential;
+    replaceEnvironment(values);
+    return { release: () => replaceEnvironment(original) };
+}
+async function resolveWorkspace(input) {
+    try {
+        const workspace = await realpath(resolve(input.runtimeContext.environment.workspace ?? input.baseDir));
+        if (!(await stat(workspace)).isDirectory())
+            throw new Error("not a directory");
+        return workspace;
+    }
+    catch {
+        throw new LifecycleError("droid_workspace_invalid", "The NeMo Fabric runtime workspace must be a directory");
+    }
+}
+function rejectMcpExtensions(name, server) {
+    if (server.extensions !== undefined && Object.keys(server.extensions).length > 0) {
+        throw new LifecycleError("droid_mcp_extensions_unsupported", "Droid does not support MCP extensions", {
+            metadata: { server: name },
+        });
+    }
+    if (server.authentication !== undefined && server.authentication !== null) {
+        throw new LifecycleError("droid_mcp_authentication_unsupported", "Droid MCP authentication is not supported by this adapter", { metadata: { server: name } });
+    }
+    if (server.allowed_tools !== undefined && server.allowed_tools !== null) {
+        throw new LifecycleError("droid_mcp_allowlist_unsupported", "Droid MCP allowed_tools filtering is not supported by this adapter", { metadata: { server: name } });
+    }
+    if (server.blocked_tools !== undefined && server.blocked_tools.length > 0) {
+        throw new LifecycleError("droid_mcp_blocklist_unsupported", "Droid MCP blocked_tools filtering is not supported by this adapter", { metadata: { server: name } });
+    }
+}
+function validateRemoteUrl(name, value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new LifecycleError("droid_mcp_url_invalid", "Droid network MCP servers require an absolute URL", {
+            metadata: { server: name },
+        });
+    }
+    const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+    if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && loopback)) {
+        throw new LifecycleError("droid_mcp_url_insecure", "Droid network MCP servers require HTTPS except for loopback development endpoints", { metadata: { server: name } });
+    }
+}
+function normalizedMcpServer(name, server) {
+    rejectMcpExtensions(name, server);
+    if (server.transport === "stdio") {
+        if (server.custom_headers !== undefined && Object.keys(server.custom_headers).length > 0) {
+            throw new LifecycleError("droid_mcp_headers_unsupported", "Droid stdio MCP servers do not support custom_headers", {
+                metadata: { server: name },
+            });
+        }
+        return {
+            name,
+            command: server.url,
+            args: server.args ?? [],
+            env: server.env ?? {},
+        };
+    }
+    if (server.transport === "streamable-http" || server.transport === "sse") {
+        if ((server.args?.length ?? 0) > 0 || Object.keys(server.env ?? {}).length > 0) {
+            throw new LifecycleError("droid_mcp_process_fields_unsupported", "Droid network MCP servers do not support args or env", { metadata: { server: name } });
+        }
+        validateRemoteUrl(name, server.url);
+        return {
+            name,
+            type: server.transport === "sse" ? "sse" : "http",
+            url: server.url,
+            headers: Object.entries(server.custom_headers ?? {}).map(([headerName, value]) => ({
+                name: headerName,
+                value,
+            })),
+        };
+    }
+    throw new LifecycleError("droid_mcp_transport_unsupported", "Droid does not support the configured MCP transport", {
+        metadata: { server: name, transport: server.transport },
+    });
+}
+function normalizedMcp(input) {
+    if (input.config.mcp?.extensions !== undefined && Object.keys(input.config.mcp.extensions).length > 0) {
+        throw new LifecycleError("droid_mcp_extensions_unsupported", "Droid does not support top-level MCP extensions");
+    }
+    return Object.entries(input.config.mcp?.servers ?? {}).map(([name, server]) => normalizedMcpServer(name, server));
+}
+function settingsHome(input, parentEnvironment) {
+    const runtimeEnvironment = input.runtimeContext.environment.env ?? {};
+    return (runtimeEnvironment.FACTORY_HOME_OVERRIDE ||
+        runtimeEnvironment.HOME ||
+        runtimeEnvironment.USERPROFILE ||
+        parentEnvironment.FACTORY_HOME_OVERRIDE ||
+        parentEnvironment.HOME ||
+        parentEnvironment.USERPROFILE);
+}
+async function customModelSettingsEnvironment(input, model, sourceHome, parentEnvironment) {
+    if (!model.startsWith("custom:") || sourceHome === undefined)
+        return {};
+    const modelId = model.slice("custom:".length);
+    let apiKey;
+    for (const filename of ["settings.json", "settings.local.json"]) {
+        try {
+            const settings = JSON.parse(await readFile(join(sourceHome, ".factory", filename), "utf8"));
+            if (typeof settings !== "object" || settings === null || !("customModels" in settings))
+                continue;
+            const customModels = settings.customModels;
+            if (!Array.isArray(customModels))
+                continue;
+            const configured = customModels.find((candidate) => typeof candidate === "object" &&
+                candidate !== null &&
+                "model" in candidate &&
+                candidate.model === modelId);
+            if (configured !== undefined && "apiKey" in configured)
+                apiKey = configured.apiKey;
+        }
+        catch (error) {
+            if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+                continue;
+            if (error instanceof SyntaxError)
+                continue; // Droid reports malformed settings during session creation.
+            throw new LifecycleError("droid_settings_unavailable", "Droid settings could not be read by NeMo Fabric");
+        }
+    }
+    if (typeof apiKey !== "string")
+        return {};
+    const match = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(apiKey);
+    if (match === null)
+        return {};
+    const name = match[1];
+    if (name === undefined)
+        return {};
+    const value = credentialValue(input, name, parentEnvironment);
+    if (value === undefined || value.length === 0) {
+        throw new LifecycleError("droid_credential_missing", `Credential environment variable ${name} is not set`);
+    }
+    return { [name]: value };
+}
+async function prepareRuntimeProfile(input, hasMcpServers, parentEnvironment, model) {
+    if (input.config.skills?.extensions !== undefined) {
+        throw new LifecycleError("droid_skill_extensions_unsupported", "Droid does not support skill extensions");
+    }
+    const configured = input.config.skills?.paths ?? [];
+    const sourceHome = settingsHome(input, parentEnvironment);
+    const settingsEnvironment = await customModelSettingsEnvironment(input, model, sourceHome, parentEnvironment);
+    if (configured.length === 0 && !hasMcpServers)
+        return { entrypoints: [], settingsEnvironment };
+    const root = await mkdtemp(join(tmpdir(), "nemo-fabric-droid-"));
+    const home = join(root, "home");
+    const factoryRoot = join(home, ".factory");
+    const skillsRoot = join(home, ".agents", "skills");
+    try {
+        if (sourceHome !== undefined) {
+            for (const filename of ["settings.json", "settings.local.json"]) {
+                const sourceSettings = join(sourceHome, ".factory", filename);
+                try {
+                    if ((await stat(sourceSettings)).isFile()) {
+                        await mkdir(factoryRoot, { recursive: true });
+                        await cp(sourceSettings, join(factoryRoot, filename), { errorOnExist: true });
+                    }
+                }
+                catch (error) {
+                    if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) {
+                        throw new LifecycleError("droid_settings_unavailable", "Droid settings could not be copied into the isolated NeMo Fabric runtime");
+                    }
+                }
+            }
+        }
+        if (configured.length > 0)
+            await mkdir(skillsRoot, { recursive: true });
+        const names = new Set();
+        const entrypoints = [];
+        for (const configuredPath of configured) {
+            let source;
+            try {
+                source = await realpath(resolve(input.baseDir, configuredPath));
+                if (!(await stat(source)).isDirectory() || !(await stat(join(source, "SKILL.md"))).isFile()) {
+                    throw new Error("invalid skill directory");
+                }
+            }
+            catch {
+                throw new LifecycleError("droid_skill_invalid", "Droid skill paths must be directories containing a SKILL.md file", { metadata: { path: configuredPath } });
+            }
+            const name = basename(source);
+            if (name.length === 0 || names.has(name)) {
+                throw new LifecycleError("droid_skill_collision", "Configured Droid skills must use distinct directory names", {
+                    metadata: { skill: name },
+                });
+            }
+            names.add(name);
+            const destination = join(skillsRoot, name);
+            await cp(source, destination, { recursive: true, errorOnExist: true });
+            entrypoints.push(await realpath(join(destination, "SKILL.md")));
+        }
+        return { root, home, entrypoints, settingsEnvironment };
+    }
+    catch (error) {
+        await rm(root, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function validateSkills(session, expectedEntrypoints) {
+    if (expectedEntrypoints.length === 0)
+        return;
+    const report = await session.listSkills();
+    if (!Array.isArray(report.skills)) {
+        throw new LifecycleError("droid_skill_status_unavailable", "Droid could not determine configured skill status");
+    }
+    const loaded = new Map();
+    for (const skill of report.skills) {
+        if (typeof skill.filePath !== "string")
+            continue;
+        try {
+            loaded.set(await realpath(skill.filePath), skill);
+        }
+        catch {
+            // A malformed or stale ambient skill cannot satisfy a configured path.
+        }
+    }
+    const missing = expectedEntrypoints.filter((entrypoint) => !loaded.has(entrypoint));
+    const disabled = expectedEntrypoints.filter((entrypoint) => loaded.get(entrypoint)?.enabled === false);
+    if (missing.length > 0 || disabled.length > 0) {
+        throw new LifecycleError("droid_skill_load_failed", "Droid did not load every configured NeMo Fabric skill", {
+            metadata: { missing, disabled },
+        });
+    }
+}
+function validNonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function validTokenCount(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function normalizeUsage(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value !== "object") {
+        throw new LifecycleError("droid_malformed_result", "Droid returned malformed usage metadata");
+    }
+    const usage = value;
+    const counts = [
+        usage.inputTokens,
+        usage.outputTokens,
+        usage.cacheCreationTokens,
+        usage.cacheReadTokens,
+        usage.thinkingTokens,
+    ];
+    if (!counts.every(validTokenCount) || (usage.factoryCredits !== undefined && !validNonNegativeNumber(usage.factoryCredits))) {
+        throw new LifecycleError("droid_malformed_result", "Droid returned malformed usage metadata");
+    }
+    const total = usage.inputTokens + usage.outputTokens;
+    if (!Number.isSafeInteger(total)) {
+        throw new LifecycleError("droid_malformed_result", "Droid returned malformed usage metadata");
+    }
+    return {
+        input_tokens: usage.inputTokens,
+        output_tokens: usage.outputTokens,
+        total_tokens: total,
+        extensions: {
+            cache_read_tokens: usage.cacheReadTokens,
+            cache_write_tokens: usage.cacheCreationTokens,
+            thinking_tokens: usage.thinkingTokens,
+            ...(usage.factoryCredits === undefined ? {} : { factory_credits: usage.factoryCredits }),
+        },
+    };
+}
+function normalizeResult(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new LifecycleError("droid_malformed_result", "Droid did not return a terminal result");
+    }
+    const result = value;
+    if (result.type !== "result" ||
+        typeof result.sessionId !== "string" ||
+        result.sessionId.length === 0 ||
+        !validTokenCount(result.durationMs) ||
+        !validTokenCount(result.turnCount) ||
+        typeof result.text !== "string" ||
+        typeof result.success !== "boolean" ||
+        typeof result.interrupted !== "boolean" ||
+        !["success", "interrupted", "error_during_execution", "error_structured_output"].includes(String(result.subtype))) {
+        throw new LifecycleError("droid_malformed_result", "Droid returned a malformed terminal result");
+    }
+    const usage = normalizeUsage(result.tokenUsage);
+    const extensions = {
+        session_id: result.sessionId,
+        finish_reason: String(result.subtype),
+        duration_ms: Number(result.durationMs),
+        turn_count: Number(result.turnCount),
+    };
+    if (result.success && result.subtype === "success" && !result.interrupted) {
+        return { status: "completed", text: result.text, ...(usage === undefined ? {} : { usage }), extensions };
+    }
+    if (result.interrupted && result.subtype === "interrupted" && !result.success) {
+        return { status: "interrupted", text: result.text, ...(usage === undefined ? {} : { usage }), extensions };
+    }
+    if (!result.success && !result.interrupted && String(result.subtype).startsWith("error_")) {
+        const error = result.error;
+        const errorMessage = error !== null && typeof error === "object" && typeof error.message === "string"
+            ? error.message
+            : result.text;
+        return {
+            status: "failed",
+            text: result.text,
+            errorMessage: errorMessage.length === 0 ? "The Droid invocation failed" : errorMessage,
+            ...(usage === undefined ? {} : { usage }),
+            extensions,
+        };
+    }
+    throw new LifecycleError("droid_malformed_result", "Droid returned inconsistent terminal result fields");
+}
+function sdkErrorMessage(error) {
+    if (error instanceof Error && error.message.trim().length > 0)
+        return error.message;
+    if (typeof error === "string" && error.trim().length > 0)
+        return error;
+    return "Droid session communication failed";
+}
+async function applyToolPolicy(session, config, mcpServers) {
+    const enabled = config.tools?.enabled;
+    const blocked = config.tools?.blocked ?? [];
+    if (enabled === undefined && blocked.length === 0)
+        return;
+    const listed = await session.listTools();
+    const mcpPrefixes = mcpServers.map((server) => `${server.name}___`);
+    const available = listed
+        .map((tool) => tool.id)
+        .filter((id) => typeof id === "string" && id.length > 0 && !mcpPrefixes.some((prefix) => id.startsWith(prefix)));
+    const malformed = listed.some((tool) => typeof tool.id !== "string" || tool.id.length === 0);
+    if (malformed || new Set(available).size !== available.length) {
+        throw new LifecycleError("droid_tool_status_invalid", "Droid returned malformed built-in tool metadata");
+    }
+    const known = new Set(available);
+    const requested = [...(enabled ?? []), ...blocked];
+    const unknown = [...new Set(requested.filter((name) => !known.has(name)))].sort();
+    if (unknown.length > 0) {
+        throw new LifecycleError("droid_tool_unknown", "One or more configured tools are not Droid built-in tool IDs", {
+            metadata: { tools: unknown },
+        });
+    }
+    const disabled = new Set(blocked);
+    if (enabled !== undefined && enabled !== null) {
+        const selected = new Set(enabled);
+        for (const name of available) {
+            if (!selected.has(name))
+                disabled.add(name);
+        }
+    }
+    await session.updateSettings({ disabledToolIds: [...disabled].sort() });
+}
+async function validateMcpTools(session, configured, timeoutMs) {
+    const expected = new Set(configured.map((server) => server.name));
+    if (expected.size === 0)
+        return;
+    const deadline = Date.now() + timeoutMs;
+    let missing = [...expected];
+    while (true) {
+        const remainingBeforeRequestMs = deadline - Date.now();
+        if (remainingBeforeRequestMs <= 0) {
+            throw new LifecycleError("droid_mcp_load_failed", "Droid did not load tools from every configured MCP server", {
+                metadata: { missing },
+            });
+        }
+        let cancelTimer = () => undefined;
+        let tools;
+        try {
+            tools = await Promise.race([
+                session.listMcpTools(),
+                new Promise((resolve) => {
+                    const timer = setTimeout(resolve, remainingBeforeRequestMs);
+                    cancelTimer = () => clearTimeout(timer);
+                }),
+            ]);
+        }
+        catch {
+            throw new LifecycleError("droid_mcp_status_unavailable", "Droid could not determine configured MCP tool status");
+        }
+        finally {
+            cancelTimer();
+        }
+        if (tools === undefined) {
+            throw new LifecycleError("droid_mcp_load_failed", "Droid did not load tools from every configured MCP server", {
+                metadata: { missing },
+            });
+        }
+        if (!Array.isArray(tools) ||
+            tools.some((tool) => typeof tool.serverName !== "string" ||
+                tool.serverName.length === 0 ||
+                typeof tool.name !== "string" ||
+                tool.name.length === 0)) {
+            throw new LifecycleError("droid_mcp_status_unavailable", "Droid returned malformed MCP tool metadata");
+        }
+        const discovered = new Set(tools.map((tool) => tool.serverName));
+        missing = [...expected].filter((name) => !discovered.has(name));
+        if (missing.length === 0)
+            return;
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            throw new LifecycleError("droid_mcp_load_failed", "Droid did not load tools from every configured MCP server", {
+                metadata: { missing },
+            });
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(MCP_STATUS_POLL_INTERVAL_MS, remainingMs)));
+    }
+}
+class DroidSdkSessionHandle {
+    session;
+    runtimeRoot;
+    stopped = false;
+    constructor(session, runtimeRoot) {
+        this.session = session;
+        this.runtimeRoot = runtimeRoot;
+    }
+    async prompt(text) {
+        if (this.stopped) {
+            throw new LifecycleError("droid_session_stopped", "The Droid session is already stopped");
+        }
+        let terminal;
+        try {
+            for await (const message of this.session.stream(text)) {
+                if (typeof message === "object" && message !== null && "type" in message && message.type === "result") {
+                    terminal = message;
+                }
+            }
+        }
+        catch (error) {
+            throw new LifecycleError("droid_session_failed", sdkErrorMessage(error), { retryable: true });
+        }
+        if (terminal === undefined) {
+            throw new LifecycleError("droid_session_failed", "Droid session ended without a terminal result", {
+                retryable: true,
+            });
+        }
+        return normalizeResult(terminal);
+    }
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        try {
+            await this.session.close();
+        }
+        finally {
+            if (this.runtimeRoot !== undefined) {
+                await rm(this.runtimeRoot, { recursive: true, force: true });
+            }
+        }
+    }
+}
+export class DroidSdkSessionFactory {
+    loader;
+    mcpStartupTimeoutMs;
+    parentEnvironment;
+    constructor(loader = loadDroidSdk, mcpStartupTimeoutMs = MCP_STARTUP_TIMEOUT_MS, parentEnvironment = process.env) {
+        this.loader = loader;
+        this.mcpStartupTimeoutMs = mcpStartupTimeoutMs;
+        this.parentEnvironment = parentEnvironment;
+    }
+    async create(input) {
+        const selected = selectModel(input.config);
+        const apiKeyEnv = selected.api_key_env;
+        if (apiKeyEnv === undefined || apiKeyEnv === null || apiKeyEnv.length === 0) {
+            throw new LifecycleError("droid_api_key_env_required", "The selected Factory model requires api_key_env");
+        }
+        const apiKey = credentialValue(input, apiKeyEnv, this.parentEnvironment);
+        if (apiKey === undefined || apiKey.length === 0) {
+            throw new LifecycleError("droid_credential_missing", `Credential environment variable ${apiKeyEnv} is not set`);
+        }
+        const workspace = await resolveWorkspace(input);
+        const mcpServers = normalizedMcp(input);
+        const instruction = input.config.instructions?.system;
+        if (instruction?.extensions !== undefined && Object.keys(instruction.extensions).length > 0) {
+            throw new LifecycleError("droid_instruction_extensions_unsupported", "Droid does not support instruction extensions");
+        }
+        if (instruction?.mode !== undefined && instruction.mode !== "replace" && instruction.mode !== "append") {
+            throw new LifecycleError("unsupported_system_instruction_mode", `Droid does not support instructions.system.mode='${instruction.mode}'; supported modes: replace, append`);
+        }
+        const runtimeProfile = await prepareRuntimeProfile(input, mcpServers.length > 0, this.parentEnvironment, selected.model);
+        const runtimeEnvironment = input.runtimeContext.environment.env ?? {};
+        const sessionEnvironment = runtimeProfile.home === undefined
+            ? { ...runtimeEnvironment, ...runtimeProfile.settingsEnvironment }
+            : {
+                ...runtimeEnvironment,
+                ...runtimeProfile.settingsEnvironment,
+                HOME: runtimeProfile.home,
+                USERPROFILE: runtimeProfile.home,
+                FACTORY_HOME_OVERRIDE: runtimeProfile.home,
+            };
+        let session;
+        try {
+            const environment = leaseEnvironment(sessionEnvironment, apiKeyEnv, apiKey, this.parentEnvironment);
+            try {
+                const sdk = await this.loader();
+                session = await sdk.createSession({
+                    cwd: workspace,
+                    modelId: selected.model,
+                    apiKey,
+                    autonomyLevel: "high",
+                    ...(mcpServers.length === 0 ? {} : { mcpServers }),
+                    env: sessionEnvironment,
+                    ...(instruction === undefined || instruction === null
+                        ? {}
+                        : {
+                            systemPrompt: instruction.mode === "append"
+                                ? { type: "preset", preset: "droid", append: instruction.content }
+                                : instruction.content,
+                        }),
+                });
+            }
+            finally {
+                environment.release();
+            }
+            await applyToolPolicy(session, input.config, mcpServers);
+            await validateMcpTools(session, mcpServers, this.mcpStartupTimeoutMs);
+            await validateSkills(session, runtimeProfile.entrypoints);
+            return new DroidSdkSessionHandle(session, runtimeProfile.root);
+        }
+        catch (error) {
+            await session?.close().catch(() => undefined);
+            if (runtimeProfile.root !== undefined) {
+                await rm(runtimeProfile.root, { recursive: true, force: true });
+            }
+            if (error instanceof LifecycleError)
+                throw error;
+            const message = sdkErrorMessage(error);
+            if (/\b(?:ENOENT|not found|spawn droid)\b/i.test(message)) {
+                throw new LifecycleError("droid_cli_unavailable", "The Factory Droid CLI is not installed or is not available on PATH");
+            }
+            throw new LifecycleError("droid_start_failed", "Factory Droid SDK initialization failed");
+        }
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { AgentRunRequest, AgentRunResult, AgentUsage, JsonObject, RuntimeContext } from "nemo-fabric-adapter-contract";
+import { type AdapterRuntime, type AdapterStartInput } from "nemo-fabric-adapters-common";
+export interface DroidPromptOutcome {
+    status: "completed" | "interrupted" | "failed";
+    text?: string;
+    errorMessage?: string;
+    usage?: AgentUsage;
+    extensions?: JsonObject;
+}
+export interface DroidSessionHandle {
+    prompt(text: string): Promise<DroidPromptOutcome>;
+    stop(): Promise<void>;
+}
+export interface DroidSessionFactory {
+    create(input: AdapterStartInput): Promise<DroidSessionHandle>;
+}
+export declare class DroidAdapterRuntime implements AdapterRuntime {
+    private readonly factory;
+    private session?;
+    constructor(factory: DroidSessionFactory);
+    start(input: AdapterStartInput): Promise<void>;
+    private invalidate;
+    invoke(request: AgentRunRequest, _context: RuntimeContext): Promise<AgentRunResult>;
+    stop(): Promise<void>;
+}

package/dist/runtime.js

@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { LifecycleError } from "nemo-fabric-adapters-common";
+function failed(code, message, usage, extensions) {
+    return {
+        status: "failed",
+        output: null,
+        error: { code, message, retryable: false },
+        ...(usage === undefined ? {} : { usage }),
+        ...(extensions === undefined ? {} : { extensions }),
+    };
+}
+export class DroidAdapterRuntime {
+    factory;
+    session;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    async start(input) {
+        if (this.session !== undefined) {
+            throw new LifecycleError("droid_already_started", "Droid adapter runtime is already started");
+        }
+        this.session = await this.factory.create(input);
+    }
+    async invalidate(session) {
+        if (this.session !== session)
+            return;
+        this.session = undefined;
+        try {
+            await session.stop();
+        }
+        catch {
+            // Preserve the invocation failure after invalidating the unusable session.
+        }
+    }
+    async invoke(request, _context) {
+        if (this.session === undefined) {
+            throw new LifecycleError("droid_not_started", "Droid adapter runtime is not started");
+        }
+        if (typeof request.input !== "string") {
+            return failed("droid_unsupported_input", "The Droid adapter accepts only plain-text input");
+        }
+        const session = this.session;
+        let outcome;
+        try {
+            outcome = await session.prompt(request.input);
+        }
+        catch (error) {
+            await this.invalidate(session);
+            if (error instanceof LifecycleError)
+                throw error;
+            throw new LifecycleError("droid_session_failed", "Droid session communication failed", { retryable: true });
+        }
+        if (outcome.status === "interrupted") {
+            return {
+                status: "cancelled",
+                output: null,
+                error: {
+                    code: "droid_interrupted",
+                    message: outcome.errorMessage ?? "The Droid invocation was interrupted",
+                    retryable: false,
+                },
+                ...(outcome.usage === undefined ? {} : { usage: outcome.usage }),
+                ...(outcome.extensions === undefined ? {} : { extensions: outcome.extensions }),
+            };
+        }
+        if (outcome.status === "failed") {
+            return failed("droid_invocation_failed", outcome.errorMessage ?? "The Droid invocation failed", outcome.usage, outcome.extensions);
+        }
+        if (outcome.text === undefined || outcome.text.length === 0) {
+            return failed("droid_no_assistant_response", "Droid completed without a final assistant text response", outcome.usage, outcome.extensions);
+        }
+        return {
+            status: "succeeded",
+            output: { response: outcome.text },
+            ...(outcome.usage === undefined ? {} : { usage: outcome.usage }),
+            ...(outcome.extensions === undefined ? {} : { extensions: outcome.extensions }),
+        };
+    }
+    async stop() {
+        const session = this.session;
+        this.session = undefined;
+        if (session !== undefined)
+            await session.stop();
+    }
+}

package/droid.fabric-adapter.json

@@ -0,0 +1,72 @@
+{
+  "contract_version": "fabric.adapter/v1alpha2",
+  "adapter_id": "nvidia.fabric.droid",
+  "adapter_kind": "process",
+  "runner": {
+    "command": "node",
+    "script": "dist/cli.js"
+  },
+  "requirements": {
+    "binaries": ["node", "droid"]
+  },
+  "config": {
+    "accepts": [
+      "models",
+      "instructions.system",
+      "tools.enabled",
+      "tools.blocked",
+      "mcp",
+      "skills"
+    ],
+    "system_instruction_modes": ["replace", "append"]
+  },
+  "settings_schema": {
+    "type": "object",
+    "properties": {},
+    "additionalProperties": false
+  },
+  "model_schema": {
+    "type": "object",
+    "properties": {
+      "provider": {"const": "factory"},
+      "model": {"type": "string", "minLength": 1},
+      "api_key_env": {"type": "string", "minLength": 1}
+    },
+    "required": ["provider", "model", "api_key_env"],
+    "additionalProperties": false
+  },
+  "extension_schemas": {
+    "run_result": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+        "session_id": {"type": "string", "minLength": 1},
+        "finish_reason": {
+          "type": "string",
+          "enum": ["success", "interrupted", "error_during_execution", "error_structured_output"]
+        },
+        "duration_ms": {"type": "integer", "minimum": 0},
+        "turn_count": {"type": "integer", "minimum": 0}
+      },
+      "required": ["session_id", "finish_reason", "duration_ms", "turn_count"],
+      "additionalProperties": false
+    },
+    "usage": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+        "cache_read_tokens": {"type": "integer", "minimum": 0},
+        "cache_write_tokens": {"type": "integer", "minimum": 0},
+        "thinking_tokens": {"type": "integer", "minimum": 0},
+        "factory_credits": {"type": "number", "minimum": 0}
+      },
+      "additionalProperties": false
+    }
+  },
+  "capabilities": {
+    "streaming": false,
+    "cancellation": false,
+    "updates": false,
+    "service": false
+  }
+}

package/package.json

@@ -1,19 +1,61 @@
 {
   "name": "nemo-fabric-adapters-droid",
-  "version": "0.0.0",
-  "description": "Inert bootstrap for NVIDIA NeMo Fabric trusted publishing. This version contains no adapter implementation.",
+  "version": "0.5.0",
+  "description": "Factory Droid SDK harness adapter for NVIDIA NeMo Fabric.",
   "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./descriptor": "./droid.fabric-adapter.json",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "nemo-fabric-adapters-droid": "dist/cli.js"
+  },
   "files": [
+    "dist",
+    "droid.fabric-adapter.json",
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "pack:check": "npm run build && node ../scripts/check-package.mjs",
+    "prepack": "npm run build",
+    "test": "npm run clean && npm run build && node --test test/*.test.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NVIDIA/NeMo-Fabric.git",
     "directory": "adapters/typescript/droid"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+  "bugs": {
+    "url": "https://github.com/NVIDIA/NeMo-Fabric/issues"
+  },
+  "homepage": "https://github.com/NVIDIA/NeMo-Fabric/tree/main/adapters/typescript/droid#readme",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dependencies": {
+    "nemo-fabric-adapter-contract": "0.5.0",
+    "nemo-fabric-adapters-common": "0.5.0"
+  },
+  "peerDependencies": {
+    "@factory/droid-sdk": "^0.9.1"
+  },
+  "peerDependenciesMeta": {
+    "@factory/droid-sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@factory/droid-sdk": "0.9.1",
+    "@types/node": "24.12.4",
+    "typescript": "5.9.3"
   }
 }