@tensor-cad/mcp 0.1.1 → 0.1.3

package/artifacts.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Where generated files go.
+ *
+ * `tensorcad_generate_code` emits a PyTorch module and the design that
+ * produced it. Given no destination it hands the contents back in the reply,
+ * which is fine for one small file and useless for anything an agent wants to
+ * run — a model it cannot put anywhere is a model it can only read.
+ *
+ * Locally the destination is a directory, and writing to it is two lines of
+ * `node:fs`. Hosted, there is no filesystem at all: a Worker has no `mkdir`,
+ * and a file written into an isolate is gone when that isolate is. So the
+ * destination is an interface, and the only thing the tool knows about it is
+ * that it takes a path and some text and says where they went.
+ *
+ * ## The reply says where, not what
+ *
+ * `location` is for a person reading the transcript — an absolute path, or an
+ * object key. `url` is what makes a hosted sink worth having: something the
+ * agent can actually fetch. A sink that has no meaningful URL omits it rather
+ * than inventing one, because a link that does not resolve is worse than no
+ * link.
+ */
+/** One emitted file, once it has been put somewhere. */
+export interface WrittenArtifact {
+    /** Where it went, in whatever terms the sink uses. */
+    location: string;
+    /** Somewhere it can be fetched from, when the sink has one. */
+    url?: string;
+}
+export interface ArtifactSink {
+    /**
+     * A short name for the place, for the sentence the tool writes.
+     *
+     * "disk" and "object storage" read very differently in a transcript, and the
+     * difference matters to whoever has to go and find the file.
+     */
+    readonly label: string;
+    /**
+     * Put one file somewhere.
+     *
+     * `prefix` is whatever the caller passed as `out_dir`, uninterpreted: a
+     * directory to a filesystem, a key prefix to a bucket. `path` is the file's
+     * own relative path, which may contain directories.
+     */
+    write(prefix: string, path: string, contents: string): Promise<WrittenArtifact>;
+}

package/bridge/server.d.ts

@@ -94,6 +94,27 @@ export declare class BridgeServer {
     private attach;
     private handle;
     private mirror;
+    /**
+     * Run `work` with this socket marked as the one causing the change.
+     *
+     * `acting` is how a change is attributed to the connection that caused it,
+     * so the editor is not sent back the document it just sent.
+     *
+     * ## The flag is held across the call, not across the promise
+     *
+     * The store's mutating calls return promises now, and the obvious rewrite is
+     * `try { return await work() } finally { acting = undefined }`. That is
+     * wrong in a way no test here catches, because it holds the flag for longer
+     * than the thing it is protecting: `subscribe` promises the listener fires
+     * *synchronously*, inside the call, before anything is awaited — so the only
+     * window that matters is the synchronous part of `work()`.
+     *
+     * Holding it across the await instead opens a window in which a second
+     * message can arrive, set `acting` to its own socket, and then have this
+     * call's `finally` clear it — attributing that message's change to nobody.
+     * Clearing it the moment `work()` yields cannot do that, because nothing
+     * else runs during a synchronous call.
+     */
     private during;
     private send;
 }

package/index.d.ts

@@ -10,7 +10,20 @@
 export { serve } from "./serve.js";
 export { createServer, SERVER_NAME, SERVER_VERSION } from "./server.js";
 export { FileStore } from "./store/file-store.js";
-export type { DocumentStore, DesignRecord, DesignSummary } from "./store/types.js";
+export { DiskSink } from "./store/disk-artifacts.js";
+export type { ArtifactSink, WrittenArtifact } from "./artifacts.js";
+/**
+ * Everything it takes to *be* a store, not just to hold one.
+ *
+ * `DocumentStore` alone is not implementable from outside this package: the
+ * two errors are part of its contract — a caller distinguishes a revision
+ * conflict from an unknown id by catching them — and the option and outcome
+ * shapes appear in its signatures. Exporting the interface without them is
+ * exporting a shape nobody else can satisfy, which is what the hosted server
+ * found on its first attempt.
+ */
+export { RevisionConflictError, UnknownDesignError, } from "./store/types.js";
+export type { DocumentStore, DesignRecord, DesignSummary, DesignSource, ApplyOutcome, CheckpointInfo, NewDesignOptions, StoreChange, StoreListener, } from "./store/types.js";
 export { TOOL_NAMES } from "./tools.js";
 export { PROMPT_NAMES } from "./prompts.js";
 export { applyOps, type Op } from "./ops.js";