GenHTTP Lambda is an MCP server published by dev.genhttp, hosted at genhttp.dev. When last checked on 2026-11-21 it was working: it answers and lists its tools. It declares 25 tools, including create_lambda, update_lambda, write_code, change_code, create_feature.
Write, deploy and host small C# web services and sites at a public address.
Nothing else in the archive shares these values.
Squares are this server's values; dots are other servers sharing them. A shared address or publisher is a lead, not proof of a common operator.
Inferred from the host name and headers: what a server runs on, not who runs it.
Create a lambda. Returns its public address and a private editor key, the only way back in. It starts with version 1 - an empty starter, or a copy of a demo. Nothing is online until deploy.
| Parameter | Type | Description |
|---|---|---|
| view | enum | How the editor opens: 'Full' (the default) shows every section, 'Simple' only the app, how it is doing and a box to ask for a change. Simple suits an owner who is not going to read the code - use it when the user asks for a simple editor, or says they are not a developer. |
| template | string | Left out, the lambda starts empty. The id of a demo from list_demos starts it as a copy of that demo, which is yours to change. |
| publicKey | string | Requested address: lower case letters, digits and dashes. Generated if omitted. |
| acceptTerms * | boolean | Must be true where the installation has terms - on a free shared machine, say, that deployments may be removed and nothing malicious is run (platform_guide, terms): the user accepts them. Ignored where it has none. |
{
"name": "create_lambda",
"title": "Create a lambda",
"description": "Create a lambda. Returns its public address and a private editor key, the only way back in. It starts with version 1 - an empty starter, or a copy of a demo. Nothing is online until deploy.",
"inputSchema": {
"type": "object",
"required": [
"acceptTerms"
],
"properties": {
"view": {
"enum": [
"Full",
"Simple",
null
],
"description": "How the editor opens: 'Full' (the default) shows every section, 'Simple' only the app, how it is doing and a box to ask for a change. Simple suits an owner who is not going to read the code - use it when the user asks for a simple editor, or says they are not a developer."
},
"template": {
"type": "string",
"description": "Left out, the lambda starts empty. The id of a demo from list_demos starts it as a copy of that demo, which is yours to change."
},
"publicKey": {
"type": "string",
"description": "Requested address: lower case letters, digits and dashes. Generated if omitted."
},
"acceptTerms": {
"type": "boolean",
"description": "Must be true where the installation has terms - on a free shared machine, say, that deployments may be removed and nothing malicious is run (platform_guide, terms): the user accepts them. Ignored where it has none."
}
}
},
"annotations": {
"title": "Create a lambda",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": false
}
}Change how a lambda's editor opens: view 'Simple' shows the app, how it is doing and a box to ask for a change - for an owner who does not write code - and 'Full' every section, the code, files, data, versions and logs included. Only the default: whoever opens the editor can switch for themselves, and that choice stays theirs. Only do this when the user asks for it.
| Parameter | Type | Description |
|---|---|---|
| view * | enum | How the editor opens: 'Full' (the default) shows every section, 'Simple' only the app, how it is doing and a box to ask for a change. Simple suits an owner who is not going to read the code - use it when the user asks for a simple editor, or says they are not a developer. |
| privateKey * | string | The editor key. |
{
"name": "update_lambda",
"title": "Change a lambda's settings",
"description": "Change how a lambda's editor opens: view 'Simple' shows the app, how it is doing and a box to ask for a change - for an owner who does not write code - and 'Full' every section, the code, files, data, versions and logs included. Only the default: whoever opens the editor can switch for themselves, and that choice stays theirs. Only do this when the user asks for it.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"view"
],
"properties": {
"view": {
"enum": [
"Full",
"Simple"
],
"description": "How the editor opens: 'Full' (the default) shows every section, 'Simple' only the app, how it is doing and a box to ask for a change. Simple suits an owner who is not going to read the code - use it when the user asks for a simple editor, or says they are not a developer."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Change a lambda's settings",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Save every file, replacing the previous set: as a new version of the lambda, or - with feature - into that feature. A version is its code and its resources. The code is every file not in resources/: its .cs files are compiled, in any folder, as in a C# project - lambda.cs returns the handler, the others hold types - and every other file is kept with it and never compiled or served: docs/product.md, docs/decisions.md, tests/README.md and the tests' scripts and data are what is written about the program, and whatever else - what a front end is built from, a tool's configuration - is laid out as you like (platform_guide, code). resources/ is what the lambda reads and serves while it runs, as Resources: the whole front end (pages, scripts, styles, icons) goes there, as part of the program - resources/web/index.html is served by Resources.App("web"). What the lambda keeps at runtime is data, never files here: records and accounts in the database (a DbContext of Entity Framework Core on await Database.GetConnectionAsync(), awaited; its schema as Evolve migrations in resources/migrations/), uploads in the workspace - and so is a large input file such as a model or a dataset (upload_file). Send the documentation and tests with the code: written with a new lambda, updated with every change, in proportion to the lambda - a few lines and one quick check for a small one. Say why with specification and change. deploy: true publishes in the same call - a version at the public address, a feature at its preview address. To send only what changes, use change_code. To change a lambda that is already in use, work in a feature.
| Parameter | Type | Description |
|---|---|---|
| check | boolean | Without deploy: compile what was saved and answer with its diagnostics, putting nothing online. |
| files * | array | lambda.cs first. |
| change | string | What this version changes, in one line written for the owner - 'Adds a leaderboard that keeps the ten best scores', not 'updated lambda.cs'. For a feature, it describes the whole feature, not the last fix. Optional, up to 500 characters. |
Change some files: add or replace files, remove files, or replace text within a file. Everything not named stays as it is, so there is no need to resend unchanged files. With feature, the change is saved into that feature - the way to work on a lambda that exists: change it as often as you like, deploy: true to try it at the feature's preview address, merge_feature when it is right. Without feature, the newest version is changed and saved as a new version. Update what the change affects in docs/ and tests/ in the same change - an edit of a passage is enough. check: true compiles without publishing. Code that does not compile is saved but never goes online.
| Parameter | Type | Description |
|---|---|---|
| check | boolean | Without deploy: compile what was saved and answer with its diagnostics, putting nothing online. |
| edits | array | Text replacements, applied after files and remove. |
| files | array | Files to add, or to replace where one of that name exists. |
| change | string | What this changes, in one line written for the owner. For a feature, it describes the whole feature, not the last fix. Optional, up to 500 characters. |
| deploy | boolean | Also deploy what was saved: a version at the public address, a feature at its preview address. |
| remove | array | Names of files to remove. |
| feature | string | Change this feature (from create_feature) instead of saving a new version. The lambda and what it has online are not touched. |
Start a feature: a place to change a lambda without touching what it has online. It branches off a version - the newest unless base names another - with a copy of its files (its documentation and tests included) and a copy of the lambda's data, and gets an address of its own to try it at. Change it with change_code or write_code and feature (deploy: true puts it online at its preview address), test it there, and merge_feature once it does what was asked. The lambda goes on serving its visitors from the version online the whole time.
| Parameter | Type | Description |
|---|---|---|
| base | ["integer","null"] | The version to branch off. Defaults to the newest - leave it out unless the user asked to start from an older one. |
| name * | string | What the feature is, in a few words for the owner - 'Leaderboard', 'Dark mode'. |
| privateKey * | string | The editor key. |
| specification | string | What the user wants from it and why, in their words where you can. Kept with the feature and passed on to the version it is merged into. Optional, up to 4000 characters. |
{
"name": "create_feature",
"title": "Start a feature",
"description": "Start a feature: a place to change a lambda without touching what it has online. It branches off a version - the newest unless base names another - with a copy of its files (its documentation and tests included) and a copy of the lambda's data, and gets an address of its own to try it at. Change it with change_code or write_code and feature (deploy: true puts it online at its preview address), test it there, and merge_feature once it does what was asked. The lambda goes on serving its visitors from the version online the whole time.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"name"
],
"properties": {
"base": {
"type": [
"integer",
"null"
],
"description": "The version to branch off. Defaults to the newest - leave it out unless the user asked to start from an older one."
},
"name": {
"type": "string",
"maxLength": 80,
"description": "What the feature is, in a few words for the owner - 'Leaderboard', 'Dark mode'."
},
"privateKey": {
"type": "string",
"description": "The editor key."
},
"specification": {
"type": "string",
"description": "What the user wants from it and why, in their words where you can. Kept with the feature and passed on to the version it is merged into. Optional, up to 4000 characters."
}
}
},
"annotations": {
"title": "Start a feature",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": false
}
}Rename a feature, change what it says about itself, or move its base. merge_feature refuses a feature that is not based on the newest version, since merging it would undo what was saved after it branched off: bring the newer versions' changes into the feature first, then move base to the newest version here. Nothing checks that the changes really are in - that is up to you.
| Parameter | Type | Description |
|---|---|---|
| base | ["integer","null"] | The version the feature is now based on, once that version's changes are in its files. |
| name | string | A new name. |
| change | string | What it changes, in one line - what the version it is merged into will say. |
| feature * | string | The feature, from create_feature or read_lambda. |
| privateKey * | string | The editor key. |
| specification | string | What the user wants from it and why. |
{
"name": "update_feature",
"title": "Change a feature's name, notes or base",
"description": "Rename a feature, change what it says about itself, or move its base. merge_feature refuses a feature that is not based on the newest version, since merging it would undo what was saved after it branched off: bring the newer versions' changes into the feature first, then move base to the newest version here. Nothing checks that the changes really are in - that is up to you.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"feature"
],
"properties": {
"base": {
"type": [
"integer",
"null"
],
"description": "The version the feature is now based on, once that version's changes are in its files."
},
"name": {
"type": "string",
"maxLength": 80,
"description": "A new name."
},
"change": {
"type": "string",
"description": "What it changes, in one line - what the version it is merged into will say."
},
"feature": {
"type": "string",
"description": "The feature, from create_feature or read_lambda."
},
"privateKey": {
"type": "string",
"description": "The editor key."
},
"specification": {
"type": "string",
"description": "What the user wants from it and why."
}
}
},
"annotations": {
"title": "Change a feature's name, notes or base",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Make a feature's files the next version of the lambda, and delete the feature with its preview and its copy of the data - the lambda's own data is not touched. Its docs/ and tests/ become the version's documentation and tests, so bring them up to date in the feature first, and run its tests against the preview. Refused while the feature is not based on the newest version (update_feature says how to get it there), and while its code does not compile. deploy: true puts the new version online at once; otherwise deploy it when the user wants it live.
| Parameter | Type | Description |
|---|---|---|
| change | string | What the new version says it changes. Left out, the feature's. |
| deploy | boolean | Also put the new version online. |
| feature * | string | The feature. |
| privateKey * | string | The editor key. |
| specification | string | What the new version keeps as what the user wanted. Left out, the feature's. |
{
"name": "merge_feature",
"title": "Merge a feature into the lambda",
"description": "Make a feature's files the next version of the lambda, and delete the feature with its preview and its copy of the data - the lambda's own data is not touched. Its docs/ and tests/ become the version's documentation and tests, so bring them up to date in the feature first, and run its tests against the preview. Refused while the feature is not based on the newest version (update_feature says how to get it there), and while its code does not compile. deploy: true puts the new version online at once; otherwise deploy it when the user wants it live.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"feature"
],
"properties": {
"change": {
"type": "string",
"description": "What the new version says it changes. Left out, the feature's."
},
"deploy": {
"type": "boolean",
"default": false,
"description": "Also put the new version online."
},
"feature": {
"type": "string",
"description": "The feature."
},
"privateKey": {
"type": "string",
"description": "The editor key."
},
"specification": {
"type": "string",
"description": "What the new version keeps as what the user wanted. Left out, the feature's."
}
}
},
"annotations": {
"title": "Merge a feature into the lambda",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": true
}
}Throw a feature away: its files, its preview and its copy of the data. The lambda is not touched. For a feature the user does not want after all.
| Parameter | Type | Description |
|---|---|---|
| feature * | string | The feature. |
| privateKey * | string | The editor key. |
{
"name": "delete_feature",
"title": "Delete a feature",
"description": "Throw a feature away: its files, its preview and its copy of the data. The lambda is not touched. For a feature the user does not want after all.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"feature"
],
"properties": {
"feature": {
"type": "string",
"description": "The feature."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Delete a feature",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Compile without saving or deploying; returns diagnostics with file and line. Does not build the handler, so deploy can still refuse a route whose return type cannot be served.
| Parameter | Type | Description |
|---|---|---|
| files * | array | lambda.cs first. The .cs files of the code are compiled, in any folder; nothing else is - send those, the rest may be left out. |
| privateKey * | string | The editor key. |
{
"name": "check_code",
"title": "Check that code compiles",
"description": "Compile without saving or deploying; returns diagnostics with file and line. Does not build the handler, so deploy can still refuse a route whose return type cannot be served.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"files"
],
"properties": {
"files": {
"type": "array",
"items": {
"type": "object",
"required": [
"name",
"code"
],
"properties": {
"code": {
"type": "string",
"description": "Contents, base64 if encoding says so."
},
"name": {
"type": "string",
"description": "lambda.cs and every other .cs file, in any folder, are compiled; 'resources/...' is read and served ('resources/web/app.js'); anything else is code kept with the version, never compiled or served - 'docs/...' and 'tests/...' are the documentation and the tests."
},
"encoding": {
"type": [
"string",
"null"
],
"default": null,
"description": "'base64' for binary files; omit otherwise."
}
}
},
"description": "lambda.cs first. The .cs files of the code are compiled, in any folder; nothing else is - send those, the rest may be left out."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Check that code compiles",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Deploy (publish) a saved version so it goes live at its public address - the newest by default. With feature, deploy that feature's files to its own preview address instead, against its copy of the data, leaving the lambda alone. Returns diagnostics on failure, and whatever was online stays online.
| Parameter | Type | Description |
|---|---|---|
| feature | string | Deploy this feature to its preview address instead of a version to the lambda's. |
| version | ["integer","null"] | Defaults to the newest. |
| privateKey * | string | The editor key. |
{
"name": "deploy",
"title": "Deploy a version or a feature",
"description": "Deploy (publish) a saved version so it goes live at its public address - the newest by default. With feature, deploy that feature's files to its own preview address instead, against its copy of the data, leaving the lambda alone. Returns diagnostics on failure, and whatever was online stays online.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"feature": {
"type": "string",
"description": "Deploy this feature to its preview address instead of a version to the lambda's."
},
"version": {
"type": [
"integer",
"null"
],
"description": "Defaults to the newest."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Deploy a version or a feature",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}A lambda's status (online version, newest version, expiry, its tier and what it may use there), its open features, the recent versions with what each was asked for and changed, its data (the database, the workspace and the secrets: whether each is on, what it holds, and which secrets the code reads that have no value yet), and one version - or, with feature, that feature: its documentation (docs/: what the app is and why, the technical decisions), how it is tested (tests/), and its files. The documentation comes first and in full up to 20,000 characters; the files come in full while they fit into 30,000 characters - the C# first, then the resources, then the rest of the code - and by name and length after that, with file to read one - a test script or its data too. Read the documentation and the history before changing what you did not write. Also how a demo is read: pass its key from list_demos.
| Parameter | Type | Description |
|---|---|---|
| file | string | Return only this file, in full however large the rest is - up to 1,048,576 characters, beyond which the zip has it. Any file of the version, 'tests/smoke.mjs' and 'resources/web/index.html' included. |
| feature | string | Read this feature - its files, its base, and which newer versions it would have to take in before it can be merged - instead of a version. |
| version | ["integer","null"] | Defaults to the newest. |
| privateKey * | string | The editor key, or the key of a demo. |
{
"name": "read_lambda",
"title": "Read a lambda",
"description": "A lambda's status (online version, newest version, expiry, its tier and what it may use there), its open features, the recent versions with what each was asked for and changed, its data (the database, the workspace and the secrets: whether each is on, what it holds, and which secrets the code reads that have no value yet), and one version - or, with feature, that feature: its documentation (docs/: what the app is and why, the technical decisions), how it is tested (tests/), and its files. The documentation comes first and in full up to 20,000 characters; the files come in full while they fit into 30,000 characters - the C# first, then the resources, then the rest of the code - and by name and length after that, with file to read one - a test script or its data too. Read the documentation and the history before changing what you did not write. Also how a demo is read: pass its key from list_demos.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"file": {
"type": "string",
"description": "Return only this file, in full however large the rest is - up to 1,048,576 characters, beyond which the zip has it. Any file of the version, 'tests/smoke.mjs' and 'resources/web/index.html' included."
},
"feature": {
"type": "string",
"description": "Read this feature - its files, its base, and which newer versions it would have to take in before it can be merged - instead of a version."
},
"version": {
"type": [
"integer",
"null"
],
"description": "Defaults to the newest."
},
"privateKey": {
"type": "string",
"description": "The editor key, or the key of a demo."
}
}
},
"annotations": {
"title": "Read a lambda",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}What a deployed lambda has been doing: its recent requests and how they were answered, what it printed, the errors it threw with their stack traces, and how much traffic it has had in the last hour and day. With feature, what that feature's preview has been doing instead, kept apart from the lambda's visitors. Call it after deploying to see that it works, and first when something is reported broken.
| Parameter | Type | Description |
|---|---|---|
| level | string | The lowest level worth reading: 'info' for everything, 'warn' for problems, 'error' for failures. |
| limit | integer | At most this many lines, the newest. |
| since | integer | The cursor a previous call answered with, to read only what is new since then. |
| feature | string | Read what this feature's preview did instead. |
| privateKey * | string | The editor key, or the key of a demo. |
{
"name": "read_logs",
"title": "Read a lambda's logs",
"description": "What a deployed lambda has been doing: its recent requests and how they were answered, what it printed, the errors it threw with their stack traces, and how much traffic it has had in the last hour and day. With feature, what that feature's preview has been doing instead, kept apart from the lambda's visitors. Call it after deploying to see that it works, and first when something is reported broken.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"level": {
"enum": [
"debug",
"info",
"warn",
"warning",
"error"
],
"type": "string",
"default": "info",
"description": "The lowest level worth reading: 'info' for everything, 'warn' for problems, 'error' for failures."
},
"limit": {
"type": "integer",
"default": 100,
"maximum": 1000,
"minimum": 1,
"description": "At most this many lines, the newest."
},
"since": {
"type": "integer",
"default": 0,
"description": "The cursor a previous call answered with, to read only what is new since then."
},
"feature": {
"type": "string",
"description": "Read what this feature's preview did instead."
},
"privateKey": {
"type": "string",
"description": "The editor key, or the key of a demo."
}
}
},
"annotations": {
"title": "Read a lambda's logs",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Write a file to the lambda's workspace - its data, which every version shares and no deploy, rollback or merge touches. With feature, to that feature's copy of the data instead, for trying things out without touching the real one. For files the lambda works with at runtime (pictures people will browse) and large input files that are not program: a model, a dataset, media. Records belong in the database, where the code writes them. Takes effect at once, without a deploy. Not for the front end: pages, scripts and styles are the program and belong in the version's resources (write_code).
| Parameter | Type | Description |
|---|---|---|
| path * | string | Relative to the workspace; slashes make folders, e.g. 'models/model.onnx'. |
| content * | string | Text, or base64 with encoding set. |
| feature | string | Write to this feature's copy of the data instead. |
| encoding | string | 'base64' for binary; omit otherwise. |
| privateKey * | string | The editor key. |
{
"name": "upload_file",
"title": "Put a file into the lambda's data",
"description": "Write a file to the lambda's workspace - its data, which every version shares and no deploy, rollback or merge touches. With feature, to that feature's copy of the data instead, for trying things out without touching the real one. For files the lambda works with at runtime (pictures people will browse) and large input files that are not program: a model, a dataset, media. Records belong in the database, where the code writes them. Takes effect at once, without a deploy. Not for the front end: pages, scripts and styles are the program and belong in the version's resources (write_code).",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"path",
"content"
],
"properties": {
"path": {
"type": "string",
"description": "Relative to the workspace; slashes make folders, e.g. 'models/model.onnx'."
},
"content": {
"type": "string",
"description": "Text, or base64 with encoding set."
},
"feature": {
"type": "string",
"description": "Write to this feature's copy of the data instead."
},
"encoding": {
"type": "string",
"description": "'base64' for binary; omit otherwise."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Put a file into the lambda's data",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}The lambda's data: whether its workspace is switched on, and every file in it with size and last write - the same whichever version is online. With feature, that feature's copy of it. The code and resources of a version are in read_lambda.
| Parameter | Type | Description |
|---|---|---|
| feature | string | List this feature's copy of the data instead. |
| privateKey * | string | The editor key, or the key of a demo. |
{
"name": "list_files",
"title": "List the lambda's data",
"description": "The lambda's data: whether its workspace is switched on, and every file in it with size and last write - the same whichever version is online. With feature, that feature's copy of it. The code and resources of a version are in read_lambda.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"feature": {
"type": "string",
"description": "List this feature's copy of the data instead."
},
"privateKey": {
"type": "string",
"description": "The editor key, or the key of a demo."
}
}
},
"annotations": {
"title": "List the lambda's data",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Remove a file, or a folder with its contents, from the workspace - the lambda's data, shared by every version. No deploy or rollback brings it back. With feature, from that feature's copy instead.
| Parameter | Type | Description |
|---|---|---|
| path * | string | Relative to the workspace. |
| feature | string | Delete from this feature's copy of the data instead. |
| privateKey * | string | The editor key. |
{
"name": "delete_file",
"title": "Delete a file from the lambda's data",
"description": "Remove a file, or a folder with its contents, from the workspace - the lambda's data, shared by every version. No deploy or rollback brings it back. With feature, from that feature's copy instead.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"path"
],
"properties": {
"path": {
"type": "string",
"description": "Relative to the workspace."
},
"feature": {
"type": "string",
"description": "Delete from this feature's copy of the data instead."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Delete a file from the lambda's data",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Switch on a kind of data the lambda needs and does not have: 'database' (a database of its own for its records - off until switched on, which makes it, empty), 'secrets' (off until switched on) or 'workspace' (on unless the owner switched it off). Do it when what you build needs it - records need the database, an API key for a service it calls needs secrets. Takes effect at once, without a deploy; switching the database on starts the lambda again on its next request, so its migrations run. There is no tool to switch one off: that deletes what it held, and is the owner's to do in the editor.
| Parameter | Type | Description |
|---|---|---|
| kind * | string | Which kind. |
| privateKey * | string | The editor key. |
{
"name": "enable_data",
"title": "Switch on a kind of data",
"description": "Switch on a kind of data the lambda needs and does not have: 'database' (a database of its own for its records - off until switched on, which makes it, empty), 'secrets' (off until switched on) or 'workspace' (on unless the owner switched it off). Do it when what you build needs it - records need the database, an API key for a service it calls needs secrets. Takes effect at once, without a deploy; switching the database on starts the lambda again on its next request, so its migrations run. There is no tool to switch one off: that deletes what it held, and is the owner's to do in the editor.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"kind"
],
"properties": {
"kind": {
"enum": [
"database",
"secrets",
"workspace"
],
"type": "string",
"description": "Which kind."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Switch on a kind of data",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Ask the operator of the installation to let a lambda's code connect to other servers - call an API with HttpClient, open a socket, a WebSocket or mail client - or read where that stands. Without it, code that connects does not compile (LAMBDA0003); a lambda whose tier connects by default (production, usually) may anyway, and read_lambda says connectivity.allowed. Ask only where the server has to make the call - a key that must not reach the browser, an API browsers may not call - and fetch a public API from the lambda's page otherwise. Say what it connects to and why. The operator decides, which takes a while: tell the user it was asked, and build what does not connect meanwhile. withdraw: true takes the request back, or gives up what was allowed - only when the user asks. With only privateKey it returns where it stands.
| Parameter | Type | Description |
|---|---|---|
| purpose | string | What it connects to and why, for the operator who decides: the addresses or services and what the lambda does with them - 'api.stripe.com, to take payments for the shop', not 'HTTP calls'. Needed to ask; left out, it returns where it stands. |
| withdraw | boolean | Take the request back, or give up what was allowed - code that connects then no longer compiles. Only when the user asks. |
| privateKey * | string | The editor key. |
{
"name": "request_connectivity",
"title": "Ask to connect to other servers",
"description": "Ask the operator of the installation to let a lambda's code connect to other servers - call an API with HttpClient, open a socket, a WebSocket or mail client - or read where that stands. Without it, code that connects does not compile (LAMBDA0003); a lambda whose tier connects by default (production, usually) may anyway, and read_lambda says connectivity.allowed. Ask only where the server has to make the call - a key that must not reach the browser, an API browsers may not call - and fetch a public API from the lambda's page otherwise. Say what it connects to and why. The operator decides, which takes a while: tell the user it was asked, and build what does not connect meanwhile. withdraw: true takes the request back, or gives up what was allowed - only when the user asks. With only privateKey it returns where it stands.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"purpose": {
"type": "string",
"maxLength": 1000,
"description": "What it connects to and why, for the operator who decides: the addresses or services and what the lambda does with them - 'api.stripe.com, to take payments for the shop', not 'HTTP calls'. Needed to ask; left out, it returns where it stands."
},
"withdraw": {
"type": "boolean",
"default": false,
"description": "Take the request back, or give up what was allowed - code that connects then no longer compiles. Only when the user asks."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Ask to connect to other servers",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}The lambda's database - its records, shared by every version: whether it is switched on, how full it is, and its tables and views with their columns and how many rows each holds. With table, a page of that table's rows, newest first, up to 100 at a time. Read only: the lambda writes it, through Database.GetConnectionAsync(). Use it to see that migrations were applied and records were written. With feature, that feature's copy.
| Parameter | Type | Description |
|---|---|---|
| limit | integer | Rows to read. |
| order | string | A column to sort by; left out, the order the rows were written in. |
| table | string | A table or view to read the rows of; left out, the tables are listed. |
| offset | integer | Rows to skip, for the next page. |
| feature | string | Read this feature's copy of the database instead. |
| ascending | boolean | Oldest or smallest first, rather than newest or largest. |
| privateKey * | string | The editor key, or the key of a demo. |
{
"name": "read_database",
"title": "Read the lambda's database",
"description": "The lambda's database - its records, shared by every version: whether it is switched on, how full it is, and its tables and views with their columns and how many rows each holds. With table, a page of that table's rows, newest first, up to 100 at a time. Read only: the lambda writes it, through Database.GetConnectionAsync(). Use it to see that migrations were applied and records were written. With feature, that feature's copy.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"limit": {
"type": "integer",
"default": 20,
"maximum": 100,
"minimum": 1,
"description": "Rows to read."
},
"order": {
"type": "string",
"description": "A column to sort by; left out, the order the rows were written in."
},
"table": {
"type": "string",
"description": "A table or view to read the rows of; left out, the tables are listed."
},
"offset": {
"type": "integer",
"default": 0,
"maximum": 2147483647,
"minimum": 0,
"description": "Rows to skip, for the next page."
},
"feature": {
"type": "string",
"description": "Read this feature's copy of the database instead."
},
"ascending": {
"type": "boolean",
"default": false,
"description": "Oldest or smallest first, rather than newest or largest."
},
"privateKey": {
"type": "string",
"description": "The editor key, or the key of a demo."
}
}
},
"annotations": {
"title": "Read the lambda's database",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Store an API key, password or token under a name the code reads with Secret.ReadAsync("NAME") - never put one in the code, a resource, the workspace, a log line or a note. The value is sealed and can never be read back, by you or the owner; only the lambda reads it, from its next call on, without a deploy. Only set a value the user gave you for this: when you do not have it, write the code with Secret.ReadAsync and tell the user to set it under Secrets in the editor (Keys and passwords in its simple view) - read_lambda and list_secrets list what is still missing. Secrets must be switched on first (enable_data). With feature, into that feature's copy (a sandbox key to try it with). Up to 100 secrets of 32 KB each.
| Parameter | Type | Description |
|---|---|---|
| name * | string | Letters, digits and underscores, not starting with a digit - conventionally upper case: 'STRIPE_KEY'. The name of an environment variable in an exported project. |
| value * | string | The value, as the user gave it. |
| feature | string | Store it in this feature's copy of the secrets instead. |
| privateKey * | string | The editor key. |
{
"name": "set_secret",
"title": "Store a secret",
"description": "Store an API key, password or token under a name the code reads with Secret.ReadAsync(\"NAME\") - never put one in the code, a resource, the workspace, a log line or a note. The value is sealed and can never be read back, by you or the owner; only the lambda reads it, from its next call on, without a deploy. Only set a value the user gave you for this: when you do not have it, write the code with Secret.ReadAsync and tell the user to set it under Secrets in the editor (Keys and passwords in its simple view) - read_lambda and list_secrets list what is still missing. Secrets must be switched on first (enable_data). With feature, into that feature's copy (a sandbox key to try it with). Up to 100 secrets of 32 KB each.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"name",
"value"
],
"properties": {
"name": {
"type": "string",
"description": "Letters, digits and underscores, not starting with a digit - conventionally upper case: 'STRIPE_KEY'. The name of an environment variable in an exported project."
},
"value": {
"type": "string",
"description": "The value, as the user gave it."
},
"feature": {
"type": "string",
"description": "Store it in this feature's copy of the secrets instead."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Store a secret",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}The lambda's secrets by name - never their values: whether secrets are switched on, what is stored and when, which names the code reads with Secret.ReadAsync and have no value yet (missing) - what the user still has to set - and which it only uses when they are there, checked with Secret.ExistsAsync (optional). With feature, that feature's copy.
| Parameter | Type | Description |
|---|---|---|
| feature | string | List this feature's copy instead. |
| privateKey * | string | The editor key, or the key of a demo. |
{
"name": "list_secrets",
"title": "List a lambda's secrets",
"description": "The lambda's secrets by name - never their values: whether secrets are switched on, what is stored and when, which names the code reads with Secret.ReadAsync and have no value yet (missing) - what the user still has to set - and which it only uses when they are there, checked with Secret.ExistsAsync (optional). With feature, that feature's copy.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"feature": {
"type": "string",
"description": "List this feature's copy instead."
},
"privateKey": {
"type": "string",
"description": "The editor key, or the key of a demo."
}
}
},
"annotations": {
"title": "List a lambda's secrets",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Remove a secret. Code that reads it with Secret.ReadAsync fails from its next call on. Only when the user asks for it, or a secret you stored yourself is no longer used. With feature, from that feature's copy instead.
| Parameter | Type | Description |
|---|---|---|
| name * | string | The name, as stored - names are case sensitive. |
| feature | string | Delete from this feature's copy instead. |
| privateKey * | string | The editor key. |
{
"name": "delete_secret",
"title": "Delete a secret",
"description": "Remove a secret. Code that reads it with Secret.ReadAsync fails from its next call on. Only when the user asks for it, or a secret you stored yourself is no longer used. With feature, from that feature's copy instead.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"name"
],
"properties": {
"name": {
"type": "string",
"description": "The name, as stored - names are case sensitive."
},
"feature": {
"type": "string",
"description": "Delete from this feature's copy instead."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Delete a secret",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Publish a lambda's source code at /source/{publicKey} for anybody to read, star and download as a .NET project, change the license it is published under, or take it down. What is published is the program and what is written about it - every version's code, resources, documentation and tests, and the history of what each changed - never its data: not the database, not the workspace, not a secret's value. Not part of building: only do this when the user asks for it, and ask which license if they did not say (MIT unless they want another). With only privateKey it returns whether it is published. Once published, everything in every version is public, older ones included: keep keys, passwords and personal data out of the files - in secrets and the database.
| Parameter | Type | Description |
|---|---|---|
| author | string | Who holds the copyright, as the license names them - the user's name or organization, only if they gave it. Left out, it stays as it is; empty, the license names 'the authors of' the lambda. |
| remove | boolean | Take the source down instead. Its stars are kept for when it is published again. |
| license | string | The SPDX identifier of the license: MIT, Apache-2.0, BSD-3-Clause, MPL-2.0, GPL-3.0-or-later, AGPL-3.0-or-later or Unlicense. Left out, it stays as it is - MIT when first published. |
| privateKey * | string | The editor key. |
{
"name": "open_source",
"title": "Publish a lambda's source code",
"description": "Publish a lambda's source code at /source/{publicKey} for anybody to read, star and download as a .NET project, change the license it is published under, or take it down. What is published is the program and what is written about it - every version's code, resources, documentation and tests, and the history of what each changed - never its data: not the database, not the workspace, not a secret's value. Not part of building: only do this when the user asks for it, and ask which license if they did not say (MIT unless they want another). With only privateKey it returns whether it is published. Once published, everything in every version is public, older ones included: keep keys, passwords and personal data out of the files - in secrets and the database.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"author": {
"type": "string",
"maxLength": 100,
"description": "Who holds the copyright, as the license names them - the user's name or organization, only if they gave it. Left out, it stays as it is; empty, the license names 'the authors of' the lambda."
},
"remove": {
"type": "boolean",
"default": false,
"description": "Take the source down instead. Its stars are kept for when it is published again."
},
"license": {
"type": "string",
"description": "The SPDX identifier of the license: MIT, Apache-2.0, BSD-3-Clause, MPL-2.0, GPL-3.0-or-later, AGPL-3.0-or-later or Unlicense. Left out, it stays as it is - MIT when first published."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Publish a lambda's source code",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}How people reach a lambda, as its owner sees it in the editor: visitors, pages opened and requests per day, and the pages, referring sites, countries, devices, browsers, operating systems and crawlers (search engines, AIs, link previews) behind them. Counted by day in UTC and written down every few minutes; a year is kept, of which the lambda's tier decides how much is shown (platform_guide, analytics). Off until switched on - nothing is counted before. enable: true switches it on, only when the user asks; switching off deletes what was counted and is the owner's to do in the editor. Use it to answer what the user asks about their visitors, or to see which pages matter before changing them.
| Parameter | Type | Description |
|---|---|---|
| days | ["integer","null"] | How many days, today included. Left out, as many as the lambda's tier shows, which is also the most. |
| enable | boolean | Switch analytics on, counting from the next request - only when the user asked for it. |
| privateKey * | string | The editor key. |
{
"name": "analytics",
"title": "Read who visits a lambda",
"description": "How people reach a lambda, as its owner sees it in the editor: visitors, pages opened and requests per day, and the pages, referring sites, countries, devices, browsers, operating systems and crawlers (search engines, AIs, link previews) behind them. Counted by day in UTC and written down every few minutes; a year is kept, of which the lambda's tier decides how much is shown (platform_guide, analytics). Off until switched on - nothing is counted before. enable: true switches it on, only when the user asks; switching off deletes what was counted and is the owner's to do in the editor. Use it to answer what the user asks about their visitors, or to see which pages matter before changing them.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"days": {
"type": [
"integer",
"null"
],
"description": "How many days, today included. Left out, as many as the lambda's tier shows, which is also the most."
},
"enable": {
"type": "boolean",
"default": false,
"description": "Switch analytics on, counting from the next request - only when the user asked for it."
},
"privateKey": {
"type": "string",
"description": "The editor key."
}
}
},
"annotations": {
"title": "Read who visits a lambda",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Demos this platform keeps online, each a finished lambda showing one way to build something: a REST API over records, registration and login, a websocket game, uploads, live updates. Their keys are public and read only: read the closest one with read_lambda (and list_files, read_logs) before writing similar code. create_lambda with a demo's id as template starts from a copy.
No parameters.
{
"name": "list_demos",
"title": "List the demos",
"description": "Demos this platform keeps online, each a finished lambda showing one way to build something: a REST API over records, registration and login, a websocket game, uploads, live updates. Their keys are public and read only: read the closest one with read_lambda (and list_files, read_logs) before writing similar code. create_lambda with a demo's id as template starts from a copy.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"annotations": {
"title": "List the demos",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}How this platform works, read first: one Markdown document in sections the other tools point to as 'platform_guide, <section>' - how versions, features and data live, git and the REST API, code and resources, paths, compiling, requests, the database, the workspace, secrets, connectivity, live updates, documentation and tests, pages meant to be found, the link back, limits and terms.
No parameters.
{
"name": "platform_guide",
"title": "Read the platform guide",
"description": "How this platform works, read first: one Markdown document in sections the other tools point to as 'platform_guide, <section>' - how versions, features and data live, git and the REST API, code and resources, paths, compiling, requests, the database, the workspace, secrets, connectivity, live updates, documentation and tests, pages meant to be found, the link back, limits and terms.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"annotations": {
"title": "Read the platform guide",
"readOnlyHint": true,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Hosts small C# web services: a snippet returns a GenHTTP handler, served at a public address. Start with platform_guide, then list_demos and read the demo closest to the task with read_lambda (their keys are public and read only). Follow their patterns. A new lambda: create_lambda, then write_code with deploy: true - nothing is reachable before. Give the user the editor key it returns: it cannot be recovered and grants write access. A lambda that exists is changed in a feature: create_feature, then change_code or write_code with feature and deploy: true to try it at its preview address (read_logs with feature), then merge_feature with deploy: true. Only a feature based on the newest version merges; if others were saved since, bring their changes in and move its base with update_feature. A version is the program and never changes: its code - its .cs files, compiled in any folder, and any other file, kept and never compiled or served - and its resources in resources/, what it reads and serves (Resources.App("web") serves resources/web/): the front end, its migrations. Data - the database, the workspace, the secrets - is shared by every version and untouched by deploys and merges; a feature works on a copy. Records go in the database and uploads in the workspace, never in resources. Database: enable_data 'database'; the schema as Evolve migrations in resources/migrations/ (V1__Create_items.sql, never editing one that was applied, never EF's migrations or EnsureCreated); records through Entity Framework Core on await Database.GetConnectionAsync(), awaited - ToListAsync, SaveChangesAsync. demo-crud shows it. Never wait for a task (.Result, .Wait(), .GetAwaiter().GetResult()): it deadlocks and is refused. Await it: routes may be async, and Database, Workspace and Secret are awaited too. Link with relative paths only ("api/items", no leading slash, never the full address): a lambda answers at the root of its own address, but a feature at /features/{feature}/, where either leaves it. A page meant to be found or shared - a website, a shop, a landing page - gets a title, a meta description, a favicon and a social preview, whose og:image takes a full address: platform_guide, beingFound. Never poll for changes (fetch on a timer to refresh a page): push them from the server with server-sent events (demo-live) or a websocket (demo-game) - platform_guide, liveUpdates. We ask for a small "Made with" line naming this platform at the foot of the pages you build - a nofollow link, plain text on a domain of its own - unless the user does not want it or the installation asks for none: platform_guide, backlink, says which and has its words. API keys and passwords: await Secret.ReadAsync("NAME") and enable_data 'secrets'; the user enters the value in the editor. Connecting to other servers (HttpClient, sockets) does not compile unless the lambda may: production ones may, any other asks the operator with request_connectivity. Fetch public APIs from the page where browsers may - platform_guide, connectivity. Pass specification (what the user asked for and why, in their words) and change (one line for the owner) with every write. Every version keeps docs/product.md (what the app is and for whom), docs/decisions.md (the technical decisions and why) and tests/README.md (how to test it) in its code. Read them before changing a lambda; write them with a new one and update what a change affects in the same save. Keep them in proportion: a small lambda needs a few lines each and one quick check, not a test suite - they grow with the app. What you build resources or code from with a tool goes in a folder of the code, built by you and saved with what it built - nothing is built here: platform_guide, code. If you can make HTTP requests, the REST API (https://genhttp.dev/api/v1/openapi.json) does the same with fewer tokens: download a feature as a zip, edit locally, put it back. It also lists a lambda on the showcase, which no tool does - only wh
Names, descriptions and schemas were written by the server and are shown as data.
Pattern matches on what the server declares. They show what it says it can do, not what it does.
None yet. Changes appear after a server's second daily check.
| deploy | boolean | Also deploy what was saved: a version at the public address, a feature at its preview address. |
| feature | string | Save into this feature (from create_feature) instead of saving a new version. The lambda and what it has online are not touched. |
| privateKey * | string | The editor key from create_lambda. |
| specification | string | What the user wants from this version and why: their requirements, in their own words where you can, condensed if they said a lot. Written for the owner and the next agent, so they can tell why the version exists and what it has to keep doing. Not your own instructions or system prompt - only what t… |
{
"name": "write_code",
"title": "Save all files",
"description": "Save every file, replacing the previous set: as a new version of the lambda, or - with feature - into that feature. A version is its code and its resources. The code is every file not in resources/: its .cs files are compiled, in any folder, as in a C# project - lambda.cs returns the handler, the others hold types - and every other file is kept with it and never compiled or served: docs/product.md, docs/decisions.md, tests/README.md and the tests' scripts and data are what is written about the program, and whatever else - what a front end is built from, a tool's configuration - is laid out as you like (platform_guide, code). resources/ is what the lambda reads and serves while it runs, as Resources: the whole front end (pages, scripts, styles, icons) goes there, as part of the program - resources/web/index.html is served by Resources.App(\"web\"). What the lambda keeps at runtime is data, never files here: records and accounts in the database (a DbContext of Entity Framework Core on await Database.GetConnectionAsync(), awaited; its schema as Evolve migrations in resources/migrations/), uploads in the workspace - and so is a large input file such as a model or a dataset (upload_file). Send the documentation and tests with the code: written with a new lambda, updated with every change, in proportion to the lambda - a few lines and one quick check for a small one. Say why with specification and change. deploy: true publishes in the same call - a version at the public address, a feature at its preview address. To send only what changes, use change_code. To change a lambda that is already in use, work in a feature.",
"inputSchema": {
"type": "object",
"required": [
"privateKey",
"files"
],
"properties": {
"check": {
"type": "boolean",
"default": false,
"description": "Without deploy: compile what was saved and answer with its diagnostics, putting nothing online."
},
"files": {
"type": "array",
"items": {
"type": "object",
"required": [
"name",
"code"
],
"properties": {
"code": {
"type": "string",
"description": "Contents, base64 if encoding says so."
},
"name": {
"type": "string",
"description": "lambda.cs and every other .cs file, in any folder, are compiled; 'resources/...' is read and served ('resources/web/app.js'); anything else is code kept with the version, never compiled or served - 'docs/...' and 'tests/...' are the documentation and the tests."
},
"encoding": {
"type": [
"string",
"null"
],
"default": null,
"description": "'base64' for binary files; omit otherwise."
}
}
},
"description": "lambda.cs first."
},
"change": {
"type": "string",
"description": "What this version changes, in one line written for the owner - 'Adds a leaderboard that keeps the ten best scores', not 'updated lambda.cs'. For a feature, it describes the whole feature, not the last fix. Optional, up to 500 characters."
},
"deploy": {
"type": "boolean",
"default": false,
"description": "Also deploy what was saved: a version at the public address, a feature at its preview address."
},
"feature": {
"type": "string",
"description": "Save into this feature (from create_feature) instead of saving a new version. The lambda and what it has online are not touched."
},
"privateKey": {
"type": "string",
"description": "The editor key from create_lambda."
},
"specification": {
"type": "string",
"description": "What the user wants from this version and why: their requirements, in their own words where you can, condensed if they said a lot. Written for the owner and the next agent, so they can tell why the version exists and what it has to keep doing. Not your own instructions or system prompt - only what the user asked for. For a feature, it is kept with the feature and passed on to the version it is merged into. Optional, up to 4000 characters."
}
}
},
"annotations": {
"title": "Save all files",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": true
}
}| privateKey * | string | The editor key. |
| specification | string | What the user wants from this change and why: their requirements, in their own words where you can. Not your own instructions or system prompt. Kept with the version or the feature. Optional, up to 4000 characters. |
{
"name": "change_code",
"title": "Change some files",
"description": "Change some files: add or replace files, remove files, or replace text within a file. Everything not named stays as it is, so there is no need to resend unchanged files. With feature, the change is saved into that feature - the way to work on a lambda that exists: change it as often as you like, deploy: true to try it at the feature's preview address, merge_feature when it is right. Without feature, the newest version is changed and saved as a new version. Update what the change affects in docs/ and tests/ in the same change - an edit of a passage is enough. check: true compiles without publishing. Code that does not compile is saved but never goes online.",
"inputSchema": {
"type": "object",
"required": [
"privateKey"
],
"properties": {
"check": {
"type": "boolean",
"default": false,
"description": "Without deploy: compile what was saved and answer with its diagnostics, putting nothing online."
},
"edits": {
"type": "array",
"items": {
"type": "object",
"required": [
"file",
"find",
"replace"
],
"properties": {
"file": {
"type": "string",
"description": "The file to change."
},
"find": {
"type": "string",
"description": "Text that occurs exactly once in the file."
},
"replace": {
"type": "string",
"description": "What to put in its place."
}
}
},
"description": "Text replacements, applied after files and remove."
},
"files": {
"type": "array",
"items": {
"type": "object",
"required": [
"name",
"code"
],
"properties": {
"code": {
"type": "string",
"description": "Contents, base64 if encoding says so."
},
"name": {
"type": "string",
"description": "lambda.cs and every other .cs file, in any folder, are compiled; 'resources/...' is read and served ('resources/web/app.js'); anything else is code kept with the version, never compiled or served - 'docs/...' and 'tests/...' are the documentation and the tests."
},
"encoding": {
"type": [
"string",
"null"
],
"default": null,
"description": "'base64' for binary files; omit otherwise."
}
}
},
"description": "Files to add, or to replace where one of that name exists."
},
"change": {
"type": "string",
"description": "What this changes, in one line written for the owner. For a feature, it describes the whole feature, not the last fix. Optional, up to 500 characters."
},
"deploy": {
"type": "boolean",
"default": false,
"description": "Also deploy what was saved: a version at the public address, a feature at its preview address."
},
"remove": {
"type": "array",
"items": {
"type": "string"
},
"description": "Names of files to remove."
},
"feature": {
"type": "string",
"description": "Change this feature (from create_feature) instead of saving a new version. The lambda and what it has online are not touched."
},
"privateKey": {
"type": "string",
"description": "The editor key."
},
"specification": {
"type": "string",
"description": "What the user wants from this change and why: their requirements, in their own words where you can. Not your own instructions or system prompt. Kept with the version or the feature. Optional, up to 4000 characters."
}
}
},
"annotations": {
"title": "Change some files",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": true
}
}